From: vijay_ganesh Date: Sun, 13 Sep 2009 21:08:23 +0000 (+0000) Subject: added parameterized boolean variables X-Git-Url: https://git.unchartedbackwaters.co.uk/w/?a=commitdiff_plain;h=49ae11ce14e3aa111adc7856eeb7b58329993532;p=francis%2Fstp.git added parameterized boolean variables git-svn-id: https://stp-fast-prover.svn.sourceforge.net/svnroot/stp-fast-prover/trunk/stp@222 e59a4935-1847-0410-ae03-e826735625c1 --- diff --git a/scripts/Makefile.common b/scripts/Makefile.common index 2317135..ec45518 100644 --- a/scripts/Makefile.common +++ b/scripts/Makefile.common @@ -4,7 +4,7 @@ #information always use full screen mode to view/edit this file in #emacs -OPTIMIZE = -g -pg # Debugging and gprof-style profiling +#OPTIMIZE = -g -pg # Debugging and gprof-style profiling OPTIMIZE = -g # Debugging OPTIMIZE = -O3 -DNDEBUG # Maximum optimization diff --git a/src/AST/AST.h b/src/AST/AST.h index d92254a..056789c 100644 --- a/src/AST/AST.h +++ b/src/AST/AST.h @@ -1237,7 +1237,7 @@ namespace BEEV const ASTNode& orig_input); ASTVec SATBased_FiniteLoop_Refinement(MINISAT::Solver& SatSolver, - const ASTNode& original_input, + const ASTNode& original_input, const ASTNode& finiteloop, ASTNodeMap* ParamToCurrentValMap, bool absrefine_flag=false); @@ -1449,6 +1449,8 @@ namespace BEEV ASTNodeMap NewName_ReadOverWrite_Map; public: + ASTNode NewBooleanVar(const ASTNode& var, const ASTNode& param); + //print the STP solver output void PrintOutput(SOLVER_RETURN_TYPE ret); diff --git a/src/AST/ASTKind.kinds b/src/AST/ASTKind.kinds index 35e06d7..4569083 100644 --- a/src/AST/ASTKind.kinds +++ b/src/AST/ASTKind.kinds @@ -59,7 +59,8 @@ NOR 1 - Form XOR 1 - Form IFF 1 - Form IMPLIES 2 2 Form -FOR 4 4 Form +FOR 5 5 Form +PARAMBOOL 2 2 Form # array operations READ 2 2 Term diff --git a/src/AST/Transform.cpp b/src/AST/Transform.cpp index 7408073..9ef0244 100644 --- a/src/AST/Transform.cpp +++ b/src/AST/Transform.cpp @@ -14,11 +14,13 @@ * unsigned counterparts. Removes array selects and stores from * formula. Arrays are replaced by equivalent bit-vector variables */ - -#include "AST.h" #include #include #include +#include +#include +#include "AST.h" +#include "printer/printers.h" namespace BEEV { @@ -175,6 +177,24 @@ namespace BEEV } }//End of assertTransformPostConditions() + ASTNode BeevMgr::NewBooleanVar(const ASTNode& var, + const ASTNode& constant) + { + ostringstream outVar; + ostringstream outNum; + //Get the name of Boolean Var + var.PL_Print(outVar); + constant.PL_Print(outNum); + std::string str(outVar.str()); + str += "("; + str += outNum.str(); + str += ")"; + ASTNode CurrentSymbol = CreateSymbol(str.c_str()); + CurrentSymbol.SetValueWidth(0); + CurrentSymbol.SetIndexWidth(0); + return CurrentSymbol; + } + /******************************************************** * TransformFormula() * @@ -258,21 +278,43 @@ namespace BEEV break; } case FOR: - //Insert in a global list of FOR constructs. Return TRUE now - bm.GlobalList_Of_FiniteLoops.push_back(simpleForm); - return bm.CreateNode(TRUE); - break; + { + //Insert in a global list of FOR constructs. Return TRUE now + bm.GlobalList_Of_FiniteLoops.push_back(simpleForm); + return bm.CreateNode(TRUE); + break; + } + case PARAMBOOL: + { + //If the parameteric boolean variable is of the form + //VAR(const), then convert it into a Boolean variable of the + //form "VAR(const)". + // + //Else if the paramteric boolean variable is of the form + //VAR(expression), then simply return it + if(BVCONST == simpleForm[1].GetKind()) + { + result = bm.NewBooleanVar(simpleForm[0],simpleForm[1]); + } + else + { + result = simpleForm; + } + break; + } default: - if (k == SYMBOL && BOOLEAN_TYPE == simpleForm.GetType()) - result = simpleForm; - else - { - FatalError("TransformFormula: Illegal kind: ", bm.CreateNode(UNDEFINED), k); - cerr << "The input is: " << simpleForm << endl; - cerr << "The valuewidth of input is : " << simpleForm.GetValueWidth() << endl; - } - break; - } + { + if (k == SYMBOL && BOOLEAN_TYPE == simpleForm.GetType()) + result = simpleForm; + else + { + FatalError("TransformFormula: Illegal kind: ", bm.CreateNode(UNDEFINED), k); + cerr << "The input is: " << simpleForm << endl; + cerr << "The valuewidth of input is : " << simpleForm.GetValueWidth() << endl; + } + break; + } + } //end of Switch if (simpleForm.GetChildren().size() > 0) (*TransformMap)[simpleForm] = result; diff --git a/src/AST/printer/AssortedPrinters.cpp b/src/AST/printer/AssortedPrinters.cpp index c4a5879..c8f3358 100644 --- a/src/AST/printer/AssortedPrinters.cpp +++ b/src/AST/printer/AssortedPrinters.cpp @@ -167,9 +167,15 @@ namespace BEEV } //skip over introduced variables - if (f.GetKind() == SYMBOL && (_introduced_symbols.find(f) != _introduced_symbols.end())) - continue; - if (f.GetKind() == SYMBOL || (f.GetKind() == READ && f[0].GetKind() == SYMBOL && f[1].GetKind() == BVCONST)) + if (f.GetKind() == SYMBOL && + (_introduced_symbols.find(f) != _introduced_symbols.end())) + { + continue; + } + if (f.GetKind() == SYMBOL || + (f.GetKind() == READ && + f[0].GetKind() == SYMBOL && + f[1].GetKind() == BVCONST)) { os << "ASSERT( "; f.PL_Print(os,0); diff --git a/src/AST/printer/PLPrinter.cpp b/src/AST/printer/PLPrinter.cpp index de25878..1d5e7c7 100644 --- a/src/AST/printer/PLPrinter.cpp +++ b/src/AST/printer/PLPrinter.cpp @@ -173,6 +173,12 @@ namespace printer PL_Print1(os, c[2], indentation, letize); os << endl << "ENDIF"; break; + case PARAMBOOL: + PL_Print1(os, c[0], indentation, letize); + os << "("; + PL_Print1(os, c[1], indentation, letize); + os << ")"; + break; case FOR: if(expand_finitefor_flag) { diff --git a/src/abstraction-refinement/AbstractionRefinement.cpp b/src/abstraction-refinement/AbstractionRefinement.cpp index e1f4092..13f3c19 100644 --- a/src/abstraction-refinement/AbstractionRefinement.cpp +++ b/src/abstraction-refinement/AbstractionRefinement.cpp @@ -227,19 +227,6 @@ namespace BEEV return arraywrite_axiom; }//end of Create_ArrayWriteAxioms() - -// static ASTNode -// SpecialSimplify(const ASTNode& a, ASTNodeMap* VarConstMap) -// { -// assert(READ == a[0].GetKind() && -// READ == a[1].GetKind() && -// EQ == a.GetKind()); -// ASTNode a0 = GlobalBeevMgr->SimplifyTerm(a[0], VarConstMap); -// ASTNode a1 = GlobalBeevMgr->SimplifyTerm(a[1], VarConstMap); - -// return GlobalBeevMgr->CreateSimplifiedEQ(a0,a1); -// } - /****************************************************************** * FINITE FORLOOP ABSTRACTION REFINEMENT * @@ -300,8 +287,7 @@ namespace BEEV return res; } } //end of absrefine count - - + ASTVec Allretvec1; Allretvec1.push_back(ASTTrue); SOLVER_RETURN_TYPE res = SOLVER_UNDECIDED; @@ -459,9 +445,8 @@ namespace BEEV return ForloopVec; } //end of the SATBased_FiniteLoop_Refinement() - //SATBased_FiniteLoop_Refinement_UsingModel - // - //Expand the finite loop, check against model + //SATBased_FiniteLoop_Refinement_UsingModel(). Expand the finite + //loop, check against model ASTNode BeevMgr::Check_FiniteLoop_UsingModel(const ASTNode& finiteloop, ASTNodeMap* ParamToCurrentValMap, @@ -614,5 +599,209 @@ namespace BEEV return Check_FiniteLoop_UsingModel(finiteloop, &ParamToCurrentValMap, true); } //end of Check_FiniteLoop_UsingModel + + + +// /****************************************************************** +// * FINITE FORLOOP ABSTRACTION REFINEMENT +// * +// * For each 'finiteloop' in the list 'GlobalList_Of_FiniteLoops' +// * +// * Expand_FiniteLoop(finiteloop); +// * +// * The 'Expand_FiniteLoop' function expands the 'finiteloop' in a +// * counterexample-guided refinement fashion +// * +// * Once all the finiteloops have been expanded, we need to go back +// * and recheck that every discarded constraint is true with the +// * final model. A flag 'done' is set to false if atleast one +// * constraint is false during model-check, and is set to true if all +// * constraints are true during model-check. +// * +// * if the 'done' flag is true, then we terminate this refinement +// * loop. +// *****************************************************************/ + + +// SOLVER_RETURN_TYPE +// BeevMgr::SATBased_AllFiniteLoops_Refinement(MINISAT::Solver& SatSolver, +// const ASTNode& original_input) +// { +// SOLVER_RETURN_TYPE res = SOLVER_UNDECIDED; +// //cout << "The number of abs-refinement limit is " << num_absrefine << endl; +// for(int absrefine_count=0;absrefine_count < num_absrefine; absrefine_count++) +// { +// ASTVec Allretvec0; +// Allretvec0.push_back(ASTTrue); +// for(ASTVec::iterator i = GlobalList_Of_FiniteLoops.begin(), +// iend=GlobalList_Of_FiniteLoops.end(); i!=iend; i++) +// { + +// ASTNodeMap ParamToCurrentValMap; +// res = SATBased_FiniteLoop_Refinement(SatSolver, +// original_input, +// *i, +// &ParamToCurrentValMap, +// true); //absrefine flag +// if(SOLVER_UNDECIDED) +// { +// return res; +// } +// } //End of For +// } //end of absrefine count + +// res = SOLVER_UNDECIDED; +// for(ASTVec::iterator i = GlobalList_Of_FiniteLoops.begin(), +// iend=GlobalList_Of_FiniteLoops.end(); i!=iend; i++) +// { +// //cout << "The abs-refine didn't finish the job. Add the remaining formulas\n"; +// ASTNodeMap ParamToCurrentValMap; +// res = SATBased_FiniteLoop_Refinement(SatSolver, +// original_input, +// *i, +// &ParamToCurrentValMap, +// false); //absrefine flag +// if(SOLVER_UNDECIDED) +// { +// return res; +// } +// } //End of For + +// return res; +// } //end of SATBased_AllFiniteLoops_Refinement() + + +// /***************************************************************** +// * SATBased_FiniteLoop_Refinement +// * +// * 'finiteloop' is the finite loop to be expanded +// * Every finiteloop has three parts: +// * 0) Parameter Name +// * 1) Parameter initialization +// * 2) Parameter limit value +// * 3) Increment formula +// * 4) Formula Body +// * +// * ParamToCurrentValMap contains a map from parameters to their +// * current values in the recursion +// * +// * Nested FORs are allowed, but only the innermost loop can have a +// * formula in it +// *****************************************************************/ +// //SATBased_FiniteLoop_Refinement +// // +// //Expand the finite loop, check against model, and add false +// //formulas to the SAT solver +// SOLVER_RETURN_TYPE +// BeevMgr::SATBased_FiniteLoop_Refinement(MINISAT::Solver& SatSolver, +// const ASTNode& original_input, +// const ASTNode& finiteloop, +// ASTNodeMap* ParamToCurrentValMap, +// bool absrefine_flag) +// { +// //BVTypeCheck should have already checked the sanity of the input +// //FOR-formula +// ASTNode parameter = finiteloop[0]; +// int paramInit = GetUnsignedConst(finiteloop[1]); +// int paramLimit = GetUnsignedConst(finiteloop[2]); +// int paramIncrement = GetUnsignedConst(finiteloop[3]); +// ASTNode exceptFormula = finiteloop[4]; +// ASTNode formulabody = finiteloop[5]; +// int paramCurrentValue = paramInit; +// SOLVER_RETURN_TYPE res = SOLVER_UNDECIDED; + +// //Update ParamToCurrentValMap with parameter and its current +// //value. Here paramCurrentValue is the initial value +// (*ParamToCurrentValMap)[parameter] = +// CreateBVConst(finiteloop[1].GetValueWidth(),paramCurrentValue); + +// //Go recursively thru' all the FOR-constructs. +// if(FOR == formulabody.GetKind()) +// { +// ASTVec retvec; +// ASTVec retvec_innerfor; +// retvec.push_back(ASTTrue); +// while(paramCurrentValue < paramLimit) +// { +// res = +// SATBased_FiniteLoop_Refinement(SatSolver, +// original_input, +// formulabody, +// ParamToCurrentValMap, +// absrefine_flag); + +// if(SOLVER_UNDECIDED != res) +// { +// return res; +// } + +// //Update ParamToCurrentValMap with parameter and its +// //current value. FIXME: Possible leak since I am not +// //freeing the previous 'value' for the same 'key' +// paramCurrentValue = paramCurrentValue + paramIncrement; +// (*ParamToCurrentValMap)[parameter] = +// CreateBVConst(finiteloop[1].GetValueWidth(),paramCurrentValue); +// } //end of While + +// return res; +// } //end of recursion FORs + +// //Expand the leaf level FOR-construct completely +// //increment of paramCurrentValue done inside loop +// int ThisForLoopAllTrue = 0; +// ASTVec ForloopVec; +// ForloopVec.push_back(ASTTrue); +// for(;paramCurrentValue < paramLimit;) +// { +// ASTNode currentFormula; +// ASTNode currentExceptFormula = exceptFormula; +// currentExceptFormula = +// SimplifyFormula(exceptFormula, false, ParamToCurrentValMap); +// if(ASTTrue == currentExceptFormula) +// { +// currentFormula = ASTTrue; +// } +// else +// { +// currentFormula = +// SimplifyFormula(formulabody, false, ParamToCurrentValMap); +// } + +// //Check the currentformula against the model, and add it to the +// //SAT solver if it is false against the model +// if(absrefine_flag && +// ASTTrue != currentFormula && +// ASTFalse == ComputeFormulaUsingModel(currentFormula)) +// { +// currentFormula = TransformFormula_TopLevel(currentFormula); +// res = +// CallSAT_ResultCheck(SatSolver, currentFormula, original_input); +// if(SOLVER_UNDECIDED != res) +// { +// return res; +// } +// } +// if(!absrefine_flag && +// ASTTrue != currentFormula) +// { +// currentFormula = TransformFormula_TopLevel(currentFormula); +// res = +// CallSAT_ResultCheck(SatSolver, currentFormula, original_input); +// if(SOLVER_UNDECIDED != res) +// { +// return res; +// } +// } + +// //Update ParamToCurrentValMap with parameter and its current +// //value. FIXME: Possible leak since I am not freeing the +// //previous 'value' for the same 'key' +// paramCurrentValue = paramCurrentValue + paramIncrement; +// (*ParamToCurrentValMap)[parameter] = +// CreateBVConst(finiteloop[1].GetValueWidth(),paramCurrentValue); +// } //end of expanding the FOR loop + +// return res; +// } //end of SATBased_FiniteLoop_Refinement };// end of namespace BEEV diff --git a/src/parser/CVC.y b/src/parser/CVC.y index c163668..96ab730 100644 --- a/src/parser/CVC.y +++ b/src/parser/CVC.y @@ -417,8 +417,20 @@ ElseRestExpr : ELSE_TOK Expr ENDIF_TOK { $$ = $2; } ; /* Grammar for formulas */ -Formula : '(' Formula ')' { $$ = $2; } - | FORMID_TOK { $$ = new ASTNode(GlobalBeevMgr->ResolveID(*$1)); delete $1;} +Formula : '(' Formula ')' + { + $$ = $2; + } + | FORMID_TOK + { + $$ = new ASTNode(GlobalBeevMgr->ResolveID(*$1)); delete $1; + } + | FORMID_TOK '(' Expr ')' + { + $$ = new ASTNode(GlobalBeevMgr->CreateNode(PARAMBOOL,*$1,*$3)); + delete $1; + delete $3; + } | BOOLEXTRACT_TOK '(' Expr ',' NUMERAL_TOK ')' { unsigned int width = $3->GetValueWidth(); diff --git a/src/simplifier/simplifier.cpp b/src/simplifier/simplifier.cpp index 7da23e0..3c1021c 100644 --- a/src/simplifier/simplifier.cpp +++ b/src/simplifier/simplifier.cpp @@ -336,7 +336,11 @@ ASTNode Flatten(const ASTNode& a) ASTNode a = b; ASTVec ca = a.GetChildren(); - if (!(IMPLIES == kind || ITE == kind || FOR == kind || isAtomic(kind))) + if (!(IMPLIES == kind || + ITE == kind || + FOR == kind || + PARAMBOOL==kind || + isAtomic(kind))) { SortByArith(ca); a = CreateNode(kind, ca); @@ -440,14 +444,21 @@ ASTNode Flatten(const ASTNode& a) } output = pushNeg ? CreateNode(NOT, output) : output; break; + case PARAMBOOL: + { + ASTNode term = SimplifyTerm(a[1], VarConstMap); + output = CreateNode(PARAMBOOL, a[0], term); + output = pushNeg ? CreateNode(NOT, output) : output; + break; + } case BVGETBIT: { - ASTNode term = SimplifyTerm(a[0]); + ASTNode term = SimplifyTerm(a[0], VarConstMap); ASTNode thebit = a[1]; ASTNode zero = CreateZeroConst(1); ASTNode one = CreateOneConst(1); ASTNode getthebit = - SimplifyTerm(CreateTerm(BVEXTRACT, 1, term, thebit, thebit)); + SimplifyTerm(CreateTerm(BVEXTRACT, 1, term, thebit, thebit), VarConstMap); if (getthebit == zero) output = pushNeg ? ASTTrue : ASTFalse; else if (getthebit == one) diff --git a/src/to-sat/ToSAT.cpp b/src/to-sat/ToSAT.cpp index d7b96c5..2fbb438 100644 --- a/src/to-sat/ToSAT.cpp +++ b/src/to-sat/ToSAT.cpp @@ -731,7 +731,10 @@ namespace BEEV } } else - output = ASTFalse; + { + CounterExampleMap[form] = ASTFalse; + output = ASTFalse; + } break; case EQ: case BVLT: @@ -841,6 +844,10 @@ namespace BEEV FatalError("ComputeFormulaUsingModel: ITE: "\ "something is wrong with the formula: ", form); break; + case PARAMBOOL: + output = NewBooleanVar(form[0],form[1]); + output = ComputeFormulaUsingModel(output); + break; case FOR: output = Check_FiniteLoop_UsingModel(form); break; diff --git a/tests/for-tests/double-for.cvc b/tests/for-tests/double-for.cvc new file mode 100644 index 0000000..341fb8e --- /dev/null +++ b/tests/for-tests/double-for.cvc @@ -0,0 +1,331921 @@ + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +% 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); +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 +} } } ); +ASSERT ( +FOR(i0:BITVECTOR(12);0bin000000000000;0bin000000101110;0bin000000000001){ +FOR(j0:BITVECTOR(12);0bin000000000000;0bin000000101110;0bin000000000001; EXCEPT i0=j0){ + LET ij = (BVPLUS(12, BVMULT(12, i0,0bin000000101110), j0)) IN + X[ij] & X[ij] = 0bin0 +} } ); +%%%%%%%%%% (5) %%%%%%%%%% +ASSERT (X[0bin000000000010] & X[0bin000000110001] = 0bin0); +ASSERT (X[0bin000000000010] & X[0bin000000110010] = 0bin0); +ASSERT (X[0bin000000000010] & X[0bin000000110011] = 0bin0); +ASSERT (X[0bin000000000010] & X[0bin000000110100] = 0bin0); +ASSERT (X[0bin000000000010] & X[0bin000000110101] = 0bin0); +ASSERT (X[0bin000000000010] & X[0bin000000110110] = 0bin0); +ASSERT (X[0bin000000000010] & X[0bin000000110111] = 0bin0); +ASSERT (X[0bin000000000010] & X[0bin000000111000] = 0bin0); +ASSERT (X[0bin000000000010] & X[0bin000000111001] = 0bin0); +ASSERT (X[0bin000000000010] & X[0bin000000111010] = 0bin0); +ASSERT (X[0bin000000000010] & X[0bin000000111011] = 0bin0); +ASSERT (X[0bin000000000010] & X[0bin000000111100] = 0bin0); +ASSERT (X[0bin000000000010] & X[0bin000000111101] = 0bin0); +ASSERT (X[0bin000000000010] & X[0bin000000111110] = 0bin0); +ASSERT (X[0bin000000000010] & X[0bin000000111111] = 0bin0); +ASSERT (X[0bin000000000010] & X[0bin000001000000] = 0bin0); +ASSERT (X[0bin000000000010] & X[0bin000001000001] = 0bin0); +ASSERT (X[0bin000000000010] & X[0bin000001000010] = 0bin0); +ASSERT (X[0bin000000000010] & X[0bin000001000011] = 0bin0); +ASSERT (X[0bin000000000010] & X[0bin000001000100] = 0bin0); +ASSERT (X[0bin000000000010] & X[0bin000001000101] = 0bin0); +ASSERT (X[0bin000000000010] & X[0bin000001000110] = 0bin0); +ASSERT (X[0bin000000000010] & X[0bin000001000111] = 0bin0); +ASSERT (X[0bin000000000010] & X[0bin000001001000] = 0bin0); +ASSERT (X[0bin000000000010] & X[0bin000001001001] = 0bin0); +ASSERT (X[0bin000000000010] & X[0bin000001001010] = 0bin0); +ASSERT (X[0bin000000000010] & X[0bin000001001011] = 0bin0); +ASSERT (X[0bin000000000010] & X[0bin000001001100] = 0bin0); +ASSERT (X[0bin000000000010] & X[0bin000001001101] = 0bin0); +ASSERT (X[0bin000000000010] & X[0bin000001001110] = 0bin0); +ASSERT (X[0bin000000000010] & X[0bin000001001111] = 0bin0); +ASSERT (X[0bin000000000010] & X[0bin000001010000] = 0bin0); +ASSERT (X[0bin000000000010] & X[0bin000001010001] = 0bin0); +ASSERT (X[0bin000000000010] & X[0bin000001010010] = 0bin0); +ASSERT (X[0bin000000000010] & X[0bin000001010011] = 0bin0); +ASSERT (X[0bin000000000010] & X[0bin000001010100] = 0bin0); +ASSERT (X[0bin000000000010] & X[0bin000001010101] = 0bin0); +ASSERT (X[0bin000000000010] & X[0bin000001010110] = 0bin0); +ASSERT (X[0bin000000000010] & X[0bin000001010111] = 0bin0); +ASSERT (X[0bin000000000010] & X[0bin000001011000] = 0bin0); +ASSERT (X[0bin000000000010] & X[0bin000001011001] = 0bin0); +ASSERT (X[0bin000000000010] & X[0bin000001011010] = 0bin0); +ASSERT (X[0bin000000000010] & X[0bin000001011011] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000000110010] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000000110011] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000000110100] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000000110101] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000000110110] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000000110111] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000000111000] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000000111001] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000000111010] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000000111011] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000000111100] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000000111101] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000000111110] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000000111111] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001000000] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001000001] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001000010] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001000011] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001000100] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001000101] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001000110] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001000111] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001001000] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001001001] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001001010] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001001011] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001001100] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001001101] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001001110] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001001111] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001010000] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001010001] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001010010] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001010011] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001010100] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001010101] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001010110] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001010111] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001011000] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001011001] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001011010] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001011011] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001100000] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001100001] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001100010] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001100011] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001100100] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001100101] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001100110] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001100111] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001101000] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001101001] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001101010] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001101011] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001101100] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001101101] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001101110] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001101111] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001110000] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001110001] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001110010] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001110011] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001110100] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001110101] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001110110] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001110111] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001111000] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001111001] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000000011] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000000110011] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000000110100] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000000110101] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000000110110] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000000110111] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000000111000] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000000111001] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000000111010] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000000111011] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000000111100] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000000111101] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000000111110] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000000111111] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001000000] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001000001] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001000010] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001000011] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001000100] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001000101] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001000110] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001000111] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001001000] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001001001] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001001010] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001001011] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001001100] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001001101] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001001110] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001001111] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001010000] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001010001] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001010010] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001010011] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001010100] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001010101] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001010110] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001010111] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001011000] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001011001] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001011010] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001011011] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001100001] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001100010] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001100011] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001100100] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001100101] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001100110] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001100111] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001101000] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001101001] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001101010] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001101011] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001101100] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001101101] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001101110] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001101111] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001110000] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001110001] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001110010] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001110011] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001110100] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001110101] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001110110] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001110111] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001111000] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001111001] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000010001111] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000010010000] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000010010001] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000010010010] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000010010011] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000010010100] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000010010101] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000010010110] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000010010111] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000010011000] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000010011001] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000010011010] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000010011011] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000010011100] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000010011101] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000010011110] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000010011111] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000000100] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000000110100] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000000110101] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000000110110] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000000110111] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000000111000] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000000111001] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000000111010] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000000111011] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000000111100] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000000111101] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000000111110] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000000111111] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001000000] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001000001] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001000010] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001000011] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001000100] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001000101] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001000110] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001000111] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001001000] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001001001] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001001010] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001001011] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001001100] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001001101] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001001110] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001001111] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001010000] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001010001] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001010010] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001010011] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001010100] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001010101] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001010110] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001010111] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001011000] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001011001] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001011010] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001011011] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001100010] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001100011] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001100100] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001100101] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001100110] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001100111] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001101000] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001101001] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001101010] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001101011] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001101100] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001101101] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001101110] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001101111] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001110000] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001110001] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001110010] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001110011] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001110100] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001110101] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001110110] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001110111] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001111000] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001111001] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000010010000] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000010010001] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000010010010] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000010010011] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000010010100] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000010010101] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000010010110] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000010010111] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000010011000] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000010011001] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000010011010] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000010011011] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000010011100] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000010011101] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000010011110] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000010011111] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000010111110] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000010111111] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000011000000] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000011000001] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000011000010] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000011000011] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000011000100] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000011000101] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000011000110] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000011000111] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000011001000] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000011001001] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000011001010] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000000000101] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000000110101] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000000110110] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000000110111] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000000111000] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000000111001] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000000111010] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000000111011] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000000111100] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000000111101] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000000111110] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000000111111] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001000000] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001000001] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001000010] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001000011] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001000100] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001000101] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001000110] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001000111] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001001000] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001001001] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001001010] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001001011] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001001100] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001001101] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001001110] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001001111] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001010000] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001010001] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001010010] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001010011] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001010100] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001010101] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001010110] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001010111] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001011000] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001011001] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001011010] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001011011] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001100011] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001100100] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001100101] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001100110] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001100111] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001101000] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001101001] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001101010] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001101011] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001101100] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001101101] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001101110] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001101111] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001110000] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001110001] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001110010] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001110011] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001110100] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001110101] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001110110] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001110111] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001111000] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001111001] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000010010001] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000010010010] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000010010011] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000010010100] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000010010101] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000010010110] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000010010111] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000010011000] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000010011001] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000010011010] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000010011011] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000010011100] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000010011101] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000010011110] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000010011111] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000010111111] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011000000] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011000001] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011000010] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011000011] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011000100] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011000101] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011000110] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011000111] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011001000] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011001001] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011001010] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011101101] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011101110] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011101111] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011110000] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011110001] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011110010] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011110011] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011110100] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011110101] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011110110] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000000000110] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000000110110] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000000110111] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000000111000] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000000111001] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000000111010] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000000111011] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000000111100] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000000111101] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000000111110] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000000111111] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001000000] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001000001] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001000010] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001000011] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001000100] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001000101] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001000110] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001000111] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001001000] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001001001] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001001010] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001001011] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001001100] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001001101] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001001110] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001001111] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001010000] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001010001] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001010010] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001010011] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001010100] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001010101] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001010110] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001010111] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001011000] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001011001] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001011010] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001011011] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001100100] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001100101] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001100110] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001100111] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001101000] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001101001] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001101010] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001101011] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001101100] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001101101] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001101110] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001101111] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001110000] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001110001] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001110010] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001110011] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001110100] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001110101] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001110110] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001110111] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001111000] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001111001] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000010010010] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000010010011] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000010010100] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000010010101] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000010010110] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000010010111] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000010011000] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000010011001] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000010011010] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000010011011] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000010011100] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000010011101] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000010011110] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000010011111] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011000000] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011000001] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011000010] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011000011] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011000100] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011000101] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011000110] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011000111] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011001000] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011001001] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011001010] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011101110] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011101111] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011110000] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011110001] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011110010] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011110011] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011110100] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011110101] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011110110] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100011100] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100011101] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100011110] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100011111] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100100000] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100100001] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100100010] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100100011] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000000000111] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000000110111] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000000111000] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000000111001] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000000111010] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000000111011] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000000111100] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000000111101] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000000111110] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000000111111] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001000000] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001000001] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001000010] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001000011] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001000100] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001000101] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001000110] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001000111] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001001000] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001001001] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001001010] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001001011] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001001100] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001001101] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001001110] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001001111] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001010000] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001010001] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001010010] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001010011] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001010100] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001010101] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001010110] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001010111] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001011000] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001011001] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001011010] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001011011] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001100101] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001100110] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001100111] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001101000] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001101001] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001101010] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001101011] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001101100] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001101101] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001101110] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001101111] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001110000] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001110001] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001110010] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001110011] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001110100] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001110101] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001110110] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001110111] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001111000] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001111001] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000010010011] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000010010100] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000010010101] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000010010110] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000010010111] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000010011000] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000010011001] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000010011010] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000010011011] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000010011100] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000010011101] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000010011110] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000010011111] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011000001] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011000010] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011000011] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011000100] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011000101] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011000110] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011000111] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011001000] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011001001] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011001010] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011101111] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011110000] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011110001] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011110010] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011110011] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011110100] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011110101] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011110110] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100011101] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100011110] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100011111] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100100000] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100100001] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100100010] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100100011] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000101001011] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000101001100] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000101001101] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000101001110] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000101001111] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000101010000] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000101010001] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000000001000] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000000111000] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000000111001] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000000111010] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000000111011] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000000111100] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000000111101] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000000111110] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000000111111] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001000000] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001000001] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001000010] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001000011] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001000100] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001000101] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001000110] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001000111] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001001000] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001001001] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001001010] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001001011] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001001100] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001001101] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001001110] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001001111] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001010000] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001010001] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001010010] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001010011] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001010100] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001010101] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001010110] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001010111] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001011000] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001011001] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001011010] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001011011] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001100110] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001100111] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001101000] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001101001] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001101010] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001101011] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001101100] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001101101] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001101110] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001101111] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001110000] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001110001] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001110010] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001110011] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001110100] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001110101] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001110110] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001110111] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001111000] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001111001] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000010010100] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000010010101] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000010010110] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000010010111] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000010011000] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000010011001] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000010011010] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000010011011] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000010011100] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000010011101] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000010011110] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000010011111] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000011000010] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000011000011] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000011000100] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000011000101] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000011000110] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000011000111] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000011001000] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000011001001] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000011001010] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000011110000] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000011110001] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000011110010] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000011110011] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000011110100] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000011110101] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000011110110] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100011110] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100011111] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100100000] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100100001] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100100010] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100100011] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000101001100] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000101001101] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000101001110] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000101001111] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000101010000] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000101010001] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000101111010] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000101111011] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000101111100] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000101111101] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000101111110] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000101111111] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000000001001] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000000111001] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000000111010] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000000111011] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000000111100] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000000111101] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000000111110] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000000111111] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001000000] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001000001] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001000010] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001000011] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001000100] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001000101] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001000110] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001000111] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001001000] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001001001] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001001010] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001001011] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001001100] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001001101] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001001110] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001001111] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001010000] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001010001] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001010010] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001010011] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001010100] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001010101] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001010110] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001010111] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001011000] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001011001] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001011010] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001011011] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001100111] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001101000] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001101001] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001101010] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001101011] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001101100] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001101101] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001101110] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001101111] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001110000] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001110001] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001110010] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001110011] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001110100] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001110101] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001110110] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001110111] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001111000] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001111001] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000010010101] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000010010110] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000010010111] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000010011000] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000010011001] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000010011010] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000010011011] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000010011100] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000010011101] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000010011110] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000010011111] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000011000011] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000011000100] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000011000101] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000011000110] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000011000111] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000011001000] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000011001001] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000011001010] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000011110001] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000011110010] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000011110011] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000011110100] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000011110101] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000011110110] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100011111] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100100000] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100100001] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100100010] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100100011] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000101001101] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000101001110] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000101001111] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000101010000] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000101010001] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000101111011] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000101111100] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000101111101] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000101111110] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000101111111] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110101001] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110101010] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110101011] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110101100] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110101101] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000000001010] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000000111010] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000000111011] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000000111100] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000000111101] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000000111110] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000000111111] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000001000000] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000001000001] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000001000010] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000001000011] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000001000100] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000001000101] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000001000110] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000001000111] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000001001000] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000001001001] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000001001010] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000001001011] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000001001100] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000001001101] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000001001110] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000001001111] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000001010000] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000001010001] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000001010010] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000001010011] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000001010100] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000001010101] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000001010110] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000001010111] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000001011000] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000001011001] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000001011010] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000001011011] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000001101000] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000001101001] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000001101010] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000001101011] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000001101100] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000001101101] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000001101110] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000001101111] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000001110000] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000001110001] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000001110010] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000001110011] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000001110100] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000001110101] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000001110110] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000001110111] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000001111000] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000001111001] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000010010110] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000010010111] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000010011000] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000010011001] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000010011010] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000010011011] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000010011100] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000010011101] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000010011110] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000010011111] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000011000100] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000011000101] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000011000110] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000011000111] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000011001000] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000011001001] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000011001010] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000011110010] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000011110011] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000011110100] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000011110101] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000011110110] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000100100000] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000100100001] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000100100010] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000100100011] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000101001110] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000101001111] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000101010000] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000101010001] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000101111100] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000101111101] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000101111110] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000101111111] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000110101010] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000110101011] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000110101100] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000110101101] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000111011000] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000111011001] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000111011010] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000111011011] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000111011100] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000000001011] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000000111011] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000000111100] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000000111101] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000000111110] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000000111111] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000001000000] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000001000001] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000001000010] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000001000011] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000001000100] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000001000101] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000001000110] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000001000111] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000001001000] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000001001001] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000001001010] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000001001011] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000001001100] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000001001101] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000001001110] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000001001111] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000001010000] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000001010001] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000001010010] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000001010011] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000001010100] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000001010101] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000001010110] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000001010111] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000001011000] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000001011001] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000001011010] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000001011011] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000001101001] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000001101010] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000001101011] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000001101100] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000001101101] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000001101110] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000001101111] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000001110000] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000001110001] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000001110010] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000001110011] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000001110100] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000001110101] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000001110110] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000001110111] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000001111000] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000001111001] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000010010111] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000010011000] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000010011001] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000010011010] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000010011011] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000010011100] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000010011101] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000010011110] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000010011111] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000011000101] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000011000110] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000011000111] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000011001000] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000011001001] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000011001010] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000011110011] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000011110100] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000011110101] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000011110110] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000100100001] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000100100010] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000100100011] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000101001111] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000101010000] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000101010001] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000101111101] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000101111110] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000101111111] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000110101011] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000110101100] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000110101101] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000111011001] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000111011010] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000111011011] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000111011100] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin001000000111] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin001000001000] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin001000001001] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin001000001010] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000000001100] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000000111100] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000000111101] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000000111110] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000000111111] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000001000000] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000001000001] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000001000010] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000001000011] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000001000100] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000001000101] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000001000110] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000001000111] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000001001000] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000001001001] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000001001010] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000001001011] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000001001100] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000001001101] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000001001110] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000001001111] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000001010000] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000001010001] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000001010010] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000001010011] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000001010100] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000001010101] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000001010110] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000001010111] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000001011000] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000001011001] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000001011010] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000001011011] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000001101010] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000001101011] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000001101100] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000001101101] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000001101110] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000001101111] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000001110000] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000001110001] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000001110010] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000001110011] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000001110100] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000001110101] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000001110110] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000001110111] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000001111000] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000001111001] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000010011000] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000010011001] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000010011010] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000010011011] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000010011100] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000010011101] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000010011110] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000010011111] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000011000110] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000011000111] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000011001000] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000011001001] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000011001010] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000011110100] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000011110101] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000011110110] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000100100010] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000100100011] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000101010000] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000101010001] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000101111110] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000101111111] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000110101100] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000110101101] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000111011010] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000111011011] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000111011100] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001000001000] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001000001001] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001000001010] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001000110110] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001000110111] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001000111000] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001000111001] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000000001101] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000000111101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000000111110] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000000111111] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000001000000] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000001000001] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000001000010] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000001000011] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000001000100] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000001000101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000001000110] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000001000111] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000001001000] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000001001001] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000001001010] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000001001011] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000001001100] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000001001101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000001001110] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000001001111] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000001010000] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000001010001] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000001010010] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000001010011] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000001010100] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000001010101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000001010110] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000001010111] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000001011000] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000001011001] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000001011010] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000001011011] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000001101011] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000001101100] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000001101101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000001101110] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000001101111] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000001110000] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000001110001] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000001110010] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000001110011] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000001110100] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000001110101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000001110110] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000001110111] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000001111000] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000001111001] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000010011001] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000010011010] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000010011011] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000010011100] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000010011101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000010011110] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000010011111] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000011000111] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000011001000] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000011001001] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000011001010] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000011110101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000011110110] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000100100011] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000101010001] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000101111111] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000110101101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000111011011] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000111011100] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001000001001] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001000001010] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001000110111] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001000111000] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001000111001] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001001100101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001001100110] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001001100111] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001001101000] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000000001110] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000000111110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000000111111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000001000000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000001000001] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000001000010] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000001000011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000001000100] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000001000101] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000001000110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000001000111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000001001000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000001001001] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000001001010] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000001001011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000001001100] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000001001101] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000001001110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000001001111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000001010000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000001010001] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000001010010] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000001010011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000001010100] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000001010101] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000001010110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000001010111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000001011000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000001011001] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000001011010] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000001011011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000001101100] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000001101101] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000001101110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000001101111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000001110000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000001110001] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000001110010] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000001110011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000001110100] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000001110101] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000001110110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000001110111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000001111000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000001111001] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000010011010] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000010011011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000010011100] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000010011101] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000010011110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000010011111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000011001000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000011001001] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000011001010] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000011110110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000111011100] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001000001010] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001000111000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001000111001] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001001100110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001001100111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001001101000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001010010100] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001010010101] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001010010110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000000001111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000000111111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000001000000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000001000001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000001000010] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000001000011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000001000100] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000001000101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000001000110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000001000111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000001001000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000001001001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000001001010] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000001001011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000001001100] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000001001101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000001001110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000001001111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000001010000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000001010001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000001010010] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000001010011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000001010100] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000001010101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000001010110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000001010111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000001011000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000001011001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000001011010] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000001011011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000001101101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000001101110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000001101111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000001110000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000001110001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000001110010] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000001110011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000001110100] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000001110101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000001110110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000001110111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000001111000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000001111001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000010011011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000010011100] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000010011101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000010011110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000010011111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000011001001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000011001010] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001000111001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001001100111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001001101000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001010010101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001010010110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001011000011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001011000100] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001011000101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000000010000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000001000000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000001000001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000001000010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000001000011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000001000100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000001000101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000001000110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000001000111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000001001000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000001001001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000001001010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000001001011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000001001100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000001001101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000001001110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000001001111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000001010000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000001010001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000001010010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000001010011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000001010100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000001010101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000001010110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000001010111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000001011000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000001011001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000001011010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000001011011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000001101110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000001101111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000001110000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000001110001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000001110010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000001110011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000001110100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000001110101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000001110110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000001110111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000001111000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000001111001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000010011100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000010011101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000010011110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000010011111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000011001010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001001101000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001010010110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001011000100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001011000101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001011110010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001011110011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001011110100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000000010001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000001000001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000001000010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000001000011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000001000100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000001000101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000001000110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000001000111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000001001000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000001001001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000001001010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000001001011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000001001100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000001001101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000001001110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000001001111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000001010000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000001010001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000001010010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000001010011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000001010100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000001010101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000001010110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000001010111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000001011000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000001011001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000001011010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000001011011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000001101111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000001110000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000001110001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000001110010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000001110011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000001110100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000001110101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000001110110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000001110111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000001111000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000001111001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000010011101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000010011110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000010011111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001011000101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001011110011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001011110100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001100100001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001100100010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001100100011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000000010010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000001000010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000001000011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000001000100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000001000101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000001000110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000001000111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000001001000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000001001001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000001001010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000001001011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000001001100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000001001101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000001001110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000001001111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000001010000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000001010001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000001010010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000001010011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000001010100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000001010101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000001010110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000001010111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000001011000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000001011001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000001011010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000001011011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000001110000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000001110001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000001110010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000001110011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000001110100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000001110101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000001110110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000001110111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000001111000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000001111001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000010011110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000010011111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001011110100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001100100010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001100100011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001101010000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001101010001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000000010011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000001000011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000001000100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000001000101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000001000110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000001000111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000001001000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000001001001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000001001010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000001001011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000001001100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000001001101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000001001110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000001001111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000001010000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000001010001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000001010010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000001010011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000001010100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000001010101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000001010110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000001010111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000001011000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000001011001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000001011010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000001011011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000001110001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000001110010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000001110011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000001110100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000001110101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000001110110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000001110111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000001111000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000001111001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000010011111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001100100011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001101010001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001101111111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001110000000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000000010100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000001000100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000001000101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000001000110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000001000111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000001001000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000001001001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000001001010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000001001011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000001001100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000001001101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000001001110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000001001111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000001010000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000001010001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000001010010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000001010011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000001010100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000001010101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000001010110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000001010111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000001011000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000001011001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000001011010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000001011011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000001110010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000001110011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000001110100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000001110101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000001110110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000001110111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000001111000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000001111001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001110000000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001110101110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001110101111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000000010101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000001000101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000001000110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000001000111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000001001000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000001001001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000001001010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000001001011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000001001100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000001001101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000001001110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000001001111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000001010000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000001010001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000001010010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000001010011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000001010100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000001010101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000001010110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000001010111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000001011000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000001011001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000001011010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000001011011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000001110011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000001110100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000001110101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000001110110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000001110111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000001111000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000001111001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001110101111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001111011101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001111011110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000000010110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000001000110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000001000111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000001001000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000001001001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000001001010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000001001011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000001001100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000001001101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000001001110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000001001111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000001010000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000001010001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000001010010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000001010011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000001010100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000001010101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000001010110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000001010111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000001011000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000001011001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000001011010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000001011011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000001110100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000001110101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000001110110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000001110111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000001111000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000001111001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001111011110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin010000001100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin010000001101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000000010111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000001000111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000001001000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000001001001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000001001010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000001001011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000001001100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000001001101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000001001110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000001001111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000001010000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000001010001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000001010010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000001010011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000001010100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000001010101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000001010110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000001010111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000001011000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000001011001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000001011010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000001011011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000001110101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000001110110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000001110111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000001111000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000001111001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin010000001101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin010000111011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin010000111100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000000011000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000001001000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000001001001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000001001010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000001001011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000001001100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000001001101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000001001110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000001001111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000001010000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000001010001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000001010010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000001010011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000001010100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000001010101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000001010110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000001010111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000001011000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000001011001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000001011010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000001011011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000001110110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000001110111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000001111000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000001111001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010000111100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010001101010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010001101011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000000011001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000001001001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000001001010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000001001011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000001001100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000001001101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000001001110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000001001111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000001010000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000001010001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000001010010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000001010011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000001010100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000001010101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000001010110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000001010111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000001011000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000001011001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000001011010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000001011011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000001110111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000001111000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000001111001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010001101011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010010011001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010010011010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000000011010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000001001010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000001001011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000001001100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000001001101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000001001110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000001001111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000001010000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000001010001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000001010010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000001010011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000001010100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000001010101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000001010110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000001010111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000001011000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000001011001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000001011010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000001011011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000001111000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000001111001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010010011010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010011001000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010011001001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000000011011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000001001011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000001001100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000001001101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000001001110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000001001111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000001010000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000001010001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000001010010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000001010011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000001010100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000001010101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000001010110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000001010111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000001011000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000001011001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000001011010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000001011011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000001111001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010011001001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010011110111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000000011100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000001001100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000001001101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000001001110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000001001111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000001010000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000001010001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000001010010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000001010011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000001010100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000001010101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000001010110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000001010111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000001011000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000001011001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000001011010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000001011011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010100100110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000000011101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000001001101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000001001110] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000001001111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000001010000] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000001010001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000001010010] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000001010011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000001010100] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000001010101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000001010110] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000001010111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000001011000] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000001011001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000001011010] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000001011011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010101010101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000000011110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000001001110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000001001111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000001010000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000001010001] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000001010010] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000001010011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000001010100] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000001010101] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000001010110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000001010111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000001011000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000001011001] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000001011010] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000001011011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010110000100] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000000011111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000001001111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000001010000] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000001010001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000001010010] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000001010011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000001010100] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000001010101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000001010110] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000001010111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000001011000] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000001011001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000001011010] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000001011011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010110110011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000000100000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000001010000] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000001010001] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000001010010] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000001010011] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000001010100] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000001010101] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000001010110] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000001010111] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000001011000] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000001011001] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000001011010] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000001011011] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010111100010] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000000100001] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000001010001] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000001010010] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000001010011] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000001010100] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000001010101] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000001010110] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000001010111] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000001011000] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000001011001] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000001011010] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000001011011] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin011000010001] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000000100010] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000001010010] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000001010011] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000001010100] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000001010101] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000001010110] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000001010111] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000001011000] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000001011001] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000001011010] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000001011011] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin011001000000] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000000100011] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000001010011] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000001010100] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000001010101] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000001010110] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000001010111] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000001011000] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000001011001] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000001011010] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000001011011] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin011001101111] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000000100100] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000001010100] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000001010101] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000001010110] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000001010111] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000001011000] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000001011001] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000001011010] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000001011011] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin011010011110] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000000100101] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000001010101] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000001010110] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000001010111] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000001011000] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000001011001] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000001011010] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000001011011] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin011011001101] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000000100110] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000001010110] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000001010111] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000001011000] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000001011001] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000001011010] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000001011011] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin011011111100] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000000100111] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin000001010111] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin000001011000] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin000001011001] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin000001011010] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin000001011011] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin011100101011] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin000000101000] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin000001011000] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin000001011001] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin000001011010] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin000001011011] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin011101011010] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin000000101001] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin000001011001] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin000001011010] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin000001011011] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin011110001001] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin000000101010] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin000001011010] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin000001011011] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin011110111000] = 0bin0); +ASSERT (X[0bin000000101011] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin000000101100] & X[0bin000001011011] = 0bin0); +ASSERT (X[0bin000000101100] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000101100] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000101100] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000101100] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000000101100] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000000101100] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000000101100] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000000101100] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000000101100] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000000101100] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000000101100] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000000101100] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000000101100] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000000101100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000000101100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000000101100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000000101100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000000101100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000000101100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000000101100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000000101100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000000101100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000000101100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000000101100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000000101100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000000101100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000000101100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000000101100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000000101100] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000000101100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000000101100] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000000101100] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000000101100] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000000101100] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000000101100] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000000101100] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000000101100] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000000101100] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000000101100] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin000000101100] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin000000101100] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin000000101100] & X[0bin011111100111] = 0bin0); +ASSERT (X[0bin000000110001] & X[0bin000001100000] = 0bin0); +ASSERT (X[0bin000000110001] & X[0bin000001100001] = 0bin0); +ASSERT (X[0bin000000110001] & X[0bin000001100010] = 0bin0); +ASSERT (X[0bin000000110001] & X[0bin000001100011] = 0bin0); +ASSERT (X[0bin000000110001] & X[0bin000001100100] = 0bin0); +ASSERT (X[0bin000000110001] & X[0bin000001100101] = 0bin0); +ASSERT (X[0bin000000110001] & X[0bin000001100110] = 0bin0); +ASSERT (X[0bin000000110001] & X[0bin000001100111] = 0bin0); +ASSERT (X[0bin000000110001] & X[0bin000001101000] = 0bin0); +ASSERT (X[0bin000000110001] & X[0bin000001101001] = 0bin0); +ASSERT (X[0bin000000110001] & X[0bin000001101010] = 0bin0); +ASSERT (X[0bin000000110001] & X[0bin000001101011] = 0bin0); +ASSERT (X[0bin000000110001] & X[0bin000001101100] = 0bin0); +ASSERT (X[0bin000000110001] & X[0bin000001101101] = 0bin0); +ASSERT (X[0bin000000110001] & X[0bin000001101110] = 0bin0); +ASSERT (X[0bin000000110001] & X[0bin000001101111] = 0bin0); +ASSERT (X[0bin000000110001] & X[0bin000001110000] = 0bin0); +ASSERT (X[0bin000000110001] & X[0bin000001110001] = 0bin0); +ASSERT (X[0bin000000110001] & X[0bin000001110010] = 0bin0); +ASSERT (X[0bin000000110001] & X[0bin000001110011] = 0bin0); +ASSERT (X[0bin000000110001] & X[0bin000001110100] = 0bin0); +ASSERT (X[0bin000000110001] & X[0bin000001110101] = 0bin0); +ASSERT (X[0bin000000110001] & X[0bin000001110110] = 0bin0); +ASSERT (X[0bin000000110001] & X[0bin000001110111] = 0bin0); +ASSERT (X[0bin000000110001] & X[0bin000001111000] = 0bin0); +ASSERT (X[0bin000000110001] & X[0bin000001111001] = 0bin0); +ASSERT (X[0bin000000110001] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000000110001] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000000110001] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000000110001] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000000110001] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000000110001] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000000110001] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000000110001] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000000110001] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000000110001] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000000110001] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000000110001] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000110001] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000110001] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000110001] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000110001] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000001100001] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000001100010] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000001100011] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000001100100] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000001100101] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000001100110] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000001100111] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000001101000] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000001101001] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000001101010] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000001101011] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000001101100] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000001101101] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000001101110] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000001101111] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000001110000] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000001110001] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000001110010] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000001110011] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000001110100] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000001110101] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000001110110] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000001110111] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000001111000] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000001111001] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000010001111] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000010010000] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000010010001] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000010010010] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000010010011] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000010010100] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000010010101] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000010010110] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000010010111] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000010011000] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000010011001] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000010011010] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000010011011] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000010011100] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000010011101] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000010011110] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000010011111] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000110010] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000001100010] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000001100011] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000001100100] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000001100101] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000001100110] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000001100111] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000001101000] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000001101001] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000001101010] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000001101011] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000001101100] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000001101101] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000001101110] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000001101111] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000001110000] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000001110001] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000001110010] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000001110011] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000001110100] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000001110101] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000001110110] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000001110111] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000001111000] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000001111001] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000010010000] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000010010001] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000010010010] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000010010011] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000010010100] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000010010101] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000010010110] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000010010111] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000010011000] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000010011001] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000010011010] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000010011011] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000010011100] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000010011101] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000010011110] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000010011111] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000010111110] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000010111111] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000011000000] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000011000001] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000011000010] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000011000011] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000011000100] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000011000101] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000011000110] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000011000111] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000011001000] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000011001001] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000011001010] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000000110011] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000001100011] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000001100100] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000001100101] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000001100110] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000001100111] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000001101000] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000001101001] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000001101010] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000001101011] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000001101100] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000001101101] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000001101110] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000001101111] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000001110000] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000001110001] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000001110010] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000001110011] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000001110100] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000001110101] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000001110110] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000001110111] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000001111000] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000001111001] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000010010001] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000010010010] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000010010011] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000010010100] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000010010101] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000010010110] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000010010111] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000010011000] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000010011001] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000010011010] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000010011011] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000010011100] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000010011101] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000010011110] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000010011111] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000010111111] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011000000] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011000001] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011000010] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011000011] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011000100] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011000101] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011000110] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011000111] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011001000] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011001001] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011001010] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011101101] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011101110] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011101111] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011110000] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011110001] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011110010] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011110011] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011110100] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011110101] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011110110] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000000110100] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000001100100] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000001100101] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000001100110] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000001100111] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000001101000] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000001101001] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000001101010] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000001101011] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000001101100] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000001101101] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000001101110] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000001101111] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000001110000] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000001110001] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000001110010] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000001110011] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000001110100] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000001110101] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000001110110] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000001110111] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000001111000] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000001111001] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000010010010] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000010010011] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000010010100] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000010010101] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000010010110] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000010010111] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000010011000] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000010011001] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000010011010] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000010011011] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000010011100] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000010011101] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000010011110] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000010011111] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011000000] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011000001] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011000010] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011000011] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011000100] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011000101] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011000110] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011000111] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011001000] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011001001] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011001010] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011101110] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011101111] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011110000] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011110001] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011110010] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011110011] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011110100] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011110101] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011110110] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100011100] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100011101] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100011110] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100011111] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100100000] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100100001] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100100010] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100100011] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000000110101] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000001100101] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000001100110] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000001100111] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000001101000] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000001101001] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000001101010] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000001101011] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000001101100] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000001101101] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000001101110] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000001101111] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000001110000] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000001110001] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000001110010] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000001110011] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000001110100] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000001110101] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000001110110] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000001110111] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000001111000] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000001111001] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000010010011] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000010010100] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000010010101] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000010010110] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000010010111] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000010011000] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000010011001] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000010011010] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000010011011] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000010011100] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000010011101] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000010011110] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000010011111] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011000001] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011000010] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011000011] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011000100] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011000101] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011000110] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011000111] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011001000] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011001001] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011001010] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011101111] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011110000] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011110001] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011110010] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011110011] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011110100] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011110101] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011110110] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100011101] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100011110] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100011111] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100100000] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100100001] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100100010] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100100011] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000101001011] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000101001100] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000101001101] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000101001110] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000101001111] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000101010000] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000101010001] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000000110110] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000001100110] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000001100111] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000001101000] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000001101001] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000001101010] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000001101011] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000001101100] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000001101101] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000001101110] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000001101111] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000001110000] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000001110001] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000001110010] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000001110011] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000001110100] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000001110101] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000001110110] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000001110111] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000001111000] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000001111001] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000010010100] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000010010101] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000010010110] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000010010111] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000010011000] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000010011001] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000010011010] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000010011011] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000010011100] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000010011101] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000010011110] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000010011111] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000011000010] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000011000011] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000011000100] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000011000101] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000011000110] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000011000111] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000011001000] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000011001001] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000011001010] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000011110000] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000011110001] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000011110010] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000011110011] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000011110100] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000011110101] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000011110110] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100011110] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100011111] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100100000] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100100001] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100100010] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100100011] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000101001100] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000101001101] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000101001110] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000101001111] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000101010000] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000101010001] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000101111010] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000101111011] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000101111100] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000101111101] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000101111110] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000101111111] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000000110111] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000001100111] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000001101000] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000001101001] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000001101010] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000001101011] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000001101100] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000001101101] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000001101110] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000001101111] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000001110000] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000001110001] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000001110010] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000001110011] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000001110100] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000001110101] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000001110110] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000001110111] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000001111000] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000001111001] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000010010101] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000010010110] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000010010111] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000010011000] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000010011001] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000010011010] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000010011011] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000010011100] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000010011101] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000010011110] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000010011111] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000011000011] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000011000100] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000011000101] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000011000110] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000011000111] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000011001000] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000011001001] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000011001010] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000011110001] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000011110010] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000011110011] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000011110100] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000011110101] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000011110110] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100011111] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100100000] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100100001] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100100010] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100100011] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000101001101] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000101001110] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000101001111] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000101010000] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000101010001] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000101111011] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000101111100] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000101111101] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000101111110] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000101111111] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110101001] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110101010] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110101011] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110101100] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110101101] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000000111000] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000001101000] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000001101001] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000001101010] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000001101011] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000001101100] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000001101101] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000001101110] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000001101111] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000001110000] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000001110001] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000001110010] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000001110011] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000001110100] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000001110101] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000001110110] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000001110111] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000001111000] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000001111001] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000010010110] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000010010111] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000010011000] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000010011001] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000010011010] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000010011011] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000010011100] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000010011101] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000010011110] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000010011111] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000011000100] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000011000101] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000011000110] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000011000111] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000011001000] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000011001001] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000011001010] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000011110010] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000011110011] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000011110100] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000011110101] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000011110110] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000100100000] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000100100001] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000100100010] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000100100011] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000101001110] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000101001111] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000101010000] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000101010001] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000101111100] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000101111101] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000101111110] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000101111111] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000110101010] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000110101011] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000110101100] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000110101101] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000111011000] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000111011001] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000111011010] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000111011011] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000111011100] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000000111001] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000001101001] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000001101010] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000001101011] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000001101100] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000001101101] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000001101110] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000001101111] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000001110000] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000001110001] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000001110010] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000001110011] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000001110100] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000001110101] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000001110110] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000001110111] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000001111000] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000001111001] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000010010111] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000010011000] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000010011001] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000010011010] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000010011011] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000010011100] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000010011101] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000010011110] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000010011111] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000011000101] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000011000110] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000011000111] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000011001000] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000011001001] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000011001010] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000011110011] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000011110100] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000011110101] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000011110110] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000100100001] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000100100010] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000100100011] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000101001111] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000101010000] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000101010001] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000101111101] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000101111110] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000101111111] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000110101011] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000110101100] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000110101101] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000111011001] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000111011010] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000111011011] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000111011100] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin001000000111] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin001000001000] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin001000001001] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin001000001010] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000000111010] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000001101010] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000001101011] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000001101100] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000001101101] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000001101110] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000001101111] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000001110000] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000001110001] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000001110010] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000001110011] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000001110100] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000001110101] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000001110110] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000001110111] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000001111000] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000001111001] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000010011000] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000010011001] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000010011010] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000010011011] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000010011100] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000010011101] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000010011110] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000010011111] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000011000110] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000011000111] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000011001000] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000011001001] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000011001010] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000011110100] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000011110101] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000011110110] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000100100010] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000100100011] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000101010000] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000101010001] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000101111110] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000101111111] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000110101100] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000110101101] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000111011010] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000111011011] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000111011100] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001000001000] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001000001001] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001000001010] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001000110110] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001000110111] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001000111000] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001000111001] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000000111011] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000001101011] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000001101100] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000001101101] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000001101110] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000001101111] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000001110000] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000001110001] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000001110010] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000001110011] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000001110100] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000001110101] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000001110110] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000001110111] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000001111000] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000001111001] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000010011001] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000010011010] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000010011011] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000010011100] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000010011101] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000010011110] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000010011111] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000011000111] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000011001000] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000011001001] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000011001010] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000011110101] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000011110110] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000100100011] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000101010001] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000101111111] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000110101101] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000111011011] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000111011100] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001000001001] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001000001010] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001000110111] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001000111000] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001000111001] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001001100101] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001001100110] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001001100111] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001001101000] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000000111100] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000001101100] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000001101101] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000001101110] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000001101111] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000001110000] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000001110001] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000001110010] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000001110011] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000001110100] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000001110101] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000001110110] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000001110111] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000001111000] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000001111001] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000010011010] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000010011011] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000010011100] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000010011101] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000010011110] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000010011111] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000011001000] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000011001001] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000011001010] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000011110110] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000111011100] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001000001010] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001000111000] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001000111001] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001001100110] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001001100111] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001001101000] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001010010100] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001010010101] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001010010110] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000000111101] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000001101101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000001101110] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000001101111] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000001110000] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000001110001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000001110010] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000001110011] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000001110100] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000001110101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000001110110] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000001110111] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000001111000] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000001111001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000010011011] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000010011100] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000010011101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000010011110] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000010011111] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000011001001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000011001010] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001000111001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001001100111] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001001101000] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001010010101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001010010110] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001011000011] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001011000100] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001011000101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000000111110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000001101110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000001101111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000001110000] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000001110001] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000001110010] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000001110011] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000001110100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000001110101] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000001110110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000001110111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000001111000] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000001111001] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000010011100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000010011101] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000010011110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000010011111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000011001010] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001001101000] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001010010110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001011000100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001011000101] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001011110010] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001011110011] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001011110100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000000111111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000001101111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000001110000] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000001110001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000001110010] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000001110011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000001110100] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000001110101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000001110110] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000001110111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000001111000] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000001111001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000010011101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000010011110] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000010011111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001011000101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001011110011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001011110100] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001100100001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001100100010] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001100100011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000001000000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000001110000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000001110001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000001110010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000001110011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000001110100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000001110101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000001110110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000001110111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000001111000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000001111001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000010011110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000010011111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001011110100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001100100010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001100100011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001101010000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001101010001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000001000001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000001110001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000001110010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000001110011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000001110100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000001110101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000001110110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000001110111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000001111000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000001111001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000010011111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001100100011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001101010001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001101111111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001110000000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000001000010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000001110010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000001110011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000001110100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000001110101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000001110110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000001110111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000001111000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000001111001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001110000000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001110101110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001110101111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000001000011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000001110011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000001110100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000001110101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000001110110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000001110111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000001111000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000001111001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001110101111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001111011101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001111011110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000001000100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000001110100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000001110101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000001110110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000001110111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000001111000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000001111001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001111011110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin010000001100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin010000001101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000001000101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000001110101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000001110110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000001110111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000001111000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000001111001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin010000001101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin010000111011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin010000111100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000001000110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000001110110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000001110111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000001111000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000001111001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010000111100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010001101010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010001101011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000001000111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000001110111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000001111000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000001111001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010001101011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010010011001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010010011010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000001001000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000001111000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000001111001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010010011010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010011001000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010011001001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000001001001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000001111001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010011001001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010011110111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000001001010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000001111010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010100100110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000001001011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000001111011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010101010101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000001001100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000001111100] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010110000100] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000001001101] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000001111101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010110110011] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000001001110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000001111110] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010111100010] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000001001111] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000001111111] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin011000010001] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000001010000] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000010000000] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin011001000000] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000001010001] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000010000001] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin011001101111] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000001010010] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000010000010] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin011010011110] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000001010011] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000010000011] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin011011001101] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000001010100] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000010000100] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin011011111100] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000001010101] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin000010000101] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin011100101011] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin000001010110] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin000010000110] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin011101011010] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin000001010111] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin000010000111] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin011110001001] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin000001011000] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin000010001000] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin011110111000] = 0bin0); +ASSERT (X[0bin000001011001] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin000001011010] & X[0bin000010001001] = 0bin0); +ASSERT (X[0bin000001011010] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001011010] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001011010] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001011010] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001011010] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001011010] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001011010] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001011010] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000001011010] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000001011010] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000001011010] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000001011010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000001011010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000001011010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000001011010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000001011010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000001011010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000001011010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000001011010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000001011010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000001011010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000001011010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000001011010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000001011010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000001011010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000001011010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000001011010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000001011010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000001011010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000001011010] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000001011010] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000001011010] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000001011010] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000001011010] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000001011010] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000001011010] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000001011010] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000001011010] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin000001011010] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin000001011010] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin000001011010] & X[0bin011111100111] = 0bin0); +ASSERT (X[0bin000001100000] & X[0bin000010001111] = 0bin0); +ASSERT (X[0bin000001100000] & X[0bin000010010000] = 0bin0); +ASSERT (X[0bin000001100000] & X[0bin000010010001] = 0bin0); +ASSERT (X[0bin000001100000] & X[0bin000010010010] = 0bin0); +ASSERT (X[0bin000001100000] & X[0bin000010010011] = 0bin0); +ASSERT (X[0bin000001100000] & X[0bin000010010100] = 0bin0); +ASSERT (X[0bin000001100000] & X[0bin000010010101] = 0bin0); +ASSERT (X[0bin000001100000] & X[0bin000010010110] = 0bin0); +ASSERT (X[0bin000001100000] & X[0bin000010010111] = 0bin0); +ASSERT (X[0bin000001100000] & X[0bin000010011000] = 0bin0); +ASSERT (X[0bin000001100000] & X[0bin000010011001] = 0bin0); +ASSERT (X[0bin000001100000] & X[0bin000010011010] = 0bin0); +ASSERT (X[0bin000001100000] & X[0bin000010011011] = 0bin0); +ASSERT (X[0bin000001100000] & X[0bin000010011100] = 0bin0); +ASSERT (X[0bin000001100000] & X[0bin000010011101] = 0bin0); +ASSERT (X[0bin000001100000] & X[0bin000010011110] = 0bin0); +ASSERT (X[0bin000001100000] & X[0bin000010011111] = 0bin0); +ASSERT (X[0bin000001100000] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000001100000] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000001100000] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000001100000] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000001100000] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000001100000] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000001100000] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000001100000] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000001100000] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000001100000] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000001100000] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000001100000] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000001100000] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000001100000] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000001100000] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000001100000] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000001100000] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000001100000] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001100000] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001100000] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001100000] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001100000] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001100000] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001100000] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000010010000] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000010010001] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000010010010] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000010010011] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000010010100] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000010010101] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000010010110] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000010010111] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000010011000] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000010011001] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000010011010] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000010011011] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000010011100] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000010011101] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000010011110] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000010011111] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000010111110] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000010111111] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000011000000] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000011000001] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000011000010] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000011000011] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000011000100] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000011000101] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000011000110] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000011000111] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000011001000] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000011001001] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000011001010] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001100001] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000010010001] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000010010010] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000010010011] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000010010100] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000010010101] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000010010110] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000010010111] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000010011000] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000010011001] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000010011010] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000010011011] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000010011100] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000010011101] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000010011110] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000010011111] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000010111111] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011000000] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011000001] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011000010] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011000011] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011000100] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011000101] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011000110] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011000111] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011001000] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011001001] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011001010] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011101101] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011101110] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011101111] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011110000] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011110001] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011110010] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011110011] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011110100] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011110101] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011110110] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001100010] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000010010010] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000010010011] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000010010100] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000010010101] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000010010110] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000010010111] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000010011000] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000010011001] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000010011010] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000010011011] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000010011100] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000010011101] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000010011110] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000010011111] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011000000] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011000001] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011000010] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011000011] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011000100] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011000101] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011000110] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011000111] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011001000] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011001001] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011001010] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011101110] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011101111] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011110000] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011110001] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011110010] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011110011] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011110100] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011110101] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011110110] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100011100] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100011101] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100011110] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100011111] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100100000] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100100001] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100100010] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100100011] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001100011] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000010010011] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000010010100] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000010010101] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000010010110] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000010010111] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000010011000] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000010011001] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000010011010] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000010011011] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000010011100] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000010011101] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000010011110] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000010011111] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011000001] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011000010] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011000011] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011000100] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011000101] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011000110] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011000111] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011001000] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011001001] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011001010] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011101111] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011110000] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011110001] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011110010] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011110011] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011110100] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011110101] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011110110] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100011101] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100011110] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100011111] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100100000] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100100001] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100100010] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100100011] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000101001011] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000101001100] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000101001101] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000101001110] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000101001111] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000101010000] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000101010001] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001100100] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000010010100] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000010010101] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000010010110] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000010010111] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000010011000] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000010011001] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000010011010] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000010011011] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000010011100] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000010011101] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000010011110] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000010011111] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000011000010] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000011000011] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000011000100] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000011000101] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000011000110] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000011000111] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000011001000] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000011001001] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000011001010] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000011110000] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000011110001] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000011110010] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000011110011] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000011110100] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000011110101] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000011110110] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100011110] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100011111] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100100000] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100100001] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100100010] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100100011] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000101001100] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000101001101] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000101001110] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000101001111] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000101010000] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000101010001] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000101111010] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000101111011] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000101111100] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000101111101] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000101111110] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000101111111] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001100101] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000010010101] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000010010110] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000010010111] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000010011000] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000010011001] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000010011010] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000010011011] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000010011100] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000010011101] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000010011110] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000010011111] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000011000011] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000011000100] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000011000101] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000011000110] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000011000111] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000011001000] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000011001001] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000011001010] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000011110001] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000011110010] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000011110011] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000011110100] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000011110101] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000011110110] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100011111] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100100000] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100100001] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100100010] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100100011] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000101001101] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000101001110] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000101001111] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000101010000] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000101010001] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000101111011] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000101111100] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000101111101] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000101111110] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000101111111] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110101001] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110101010] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110101011] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110101100] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110101101] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000001100110] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000010010110] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000010010111] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000010011000] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000010011001] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000010011010] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000010011011] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000010011100] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000010011101] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000010011110] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000010011111] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000011000100] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000011000101] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000011000110] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000011000111] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000011001000] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000011001001] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000011001010] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000011110010] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000011110011] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000011110100] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000011110101] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000011110110] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000100100000] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000100100001] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000100100010] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000100100011] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000101001110] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000101001111] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000101010000] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000101010001] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000101111100] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000101111101] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000101111110] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000101111111] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000110101010] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000110101011] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000110101100] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000110101101] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000111011000] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000111011001] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000111011010] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000111011011] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000111011100] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000001100111] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000010010111] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000010011000] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000010011001] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000010011010] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000010011011] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000010011100] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000010011101] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000010011110] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000010011111] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000011000101] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000011000110] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000011000111] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000011001000] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000011001001] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000011001010] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000011110011] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000011110100] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000011110101] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000011110110] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000100100001] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000100100010] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000100100011] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000101001111] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000101010000] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000101010001] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000101111101] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000101111110] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000101111111] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000110101011] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000110101100] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000110101101] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000111011001] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000111011010] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000111011011] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000111011100] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin001000000111] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin001000001000] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin001000001001] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin001000001010] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000001101000] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000010011000] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000010011001] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000010011010] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000010011011] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000010011100] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000010011101] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000010011110] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000010011111] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000011000110] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000011000111] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000011001000] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000011001001] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000011001010] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000011110100] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000011110101] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000011110110] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000100100010] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000100100011] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000101010000] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000101010001] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000101111110] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000101111111] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000110101100] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000110101101] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000111011010] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000111011011] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000111011100] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001000001000] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001000001001] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001000001010] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001000110110] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001000110111] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001000111000] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001000111001] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000001101001] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000010011001] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000010011010] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000010011011] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000010011100] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000010011101] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000010011110] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000010011111] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000011000111] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000011001000] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000011001001] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000011001010] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000011110101] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000011110110] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000100100011] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000101010001] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000101111111] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000110101101] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000111011011] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000111011100] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001000001001] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001000001010] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001000110111] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001000111000] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001000111001] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001001100101] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001001100110] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001001100111] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001001101000] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000001101010] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000010011010] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000010011011] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000010011100] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000010011101] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000010011110] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000010011111] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000011001000] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000011001001] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000011001010] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000011110110] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000111011100] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001000001010] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001000111000] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001000111001] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001001100110] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001001100111] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001001101000] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001010010100] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001010010101] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001010010110] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000001101011] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000010011011] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000010011100] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000010011101] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000010011110] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000010011111] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000011001001] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000011001010] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001000111001] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001001100111] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001001101000] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001010010101] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001010010110] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001011000011] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001011000100] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001011000101] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000001101100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000010011100] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000010011101] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000010011110] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000010011111] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000011001010] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001001101000] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001010010110] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001011000100] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001011000101] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001011110010] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001011110011] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001011110100] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000001101101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000010011101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000010011110] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000010011111] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001011000101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001011110011] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001011110100] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001100100001] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001100100010] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001100100011] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000001101110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000010011110] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000010011111] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001011110100] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001100100010] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001100100011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001101010000] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001101010001] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000001101111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000010011111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001100100011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001101010001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001101111111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001110000000] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000001110000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000010100000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001110000000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001110101110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001110101111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000001110001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000010100001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001110101111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001111011101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001111011110] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000001110010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000010100010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001111011110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin010000001100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin010000001101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000001110011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000010100011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin010000001101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin010000111011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin010000111100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000001110100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000010100100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010000111100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010001101010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010001101011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000001110101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000010100101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010001101011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010010011001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010010011010] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000001110110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000010100110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010010011010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010011001000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010011001001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000001110111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000010100111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010011001001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010011110111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000001111000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000010101000] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010100100110] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000001111001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000010101001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010101010101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000001111010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000010101010] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010110000100] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000001111011] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000010101011] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010110110011] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000001111100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000010101100] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010111100010] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000001111101] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000010101101] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin011000010001] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000001111110] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000010101110] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin011001000000] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000001111111] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000010101111] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin011001101111] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000010000000] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000010110000] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin011010011110] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000010000001] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000010110001] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin011011001101] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000010000010] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin000010110010] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin011011111100] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000010000011] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin000010110011] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin011100101011] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin000010000100] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin000010110100] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin011101011010] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin000010000101] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin000010110101] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin011110001001] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin000010000110] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin000010110110] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin011110111000] = 0bin0); +ASSERT (X[0bin000010000111] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin000010001000] & X[0bin000010110111] = 0bin0); +ASSERT (X[0bin000010001000] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000010001000] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000010001000] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000010001000] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000010001000] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000010001000] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000010001000] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000010001000] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000010001000] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000010001000] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000010001000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000010001000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000010001000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000010001000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000010001000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000010001000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000010001000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000010001000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000010001000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000010001000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000010001000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000010001000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000010001000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000010001000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000010001000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000010001000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000010001000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000010001000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000010001000] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000010001000] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000010001000] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000010001000] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000010001000] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000010001000] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000010001000] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000010001000] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000010001000] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin000010001000] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin000010001000] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin000010001000] & X[0bin011111100111] = 0bin0); +ASSERT (X[0bin000010001111] & X[0bin000010111110] = 0bin0); +ASSERT (X[0bin000010001111] & X[0bin000010111111] = 0bin0); +ASSERT (X[0bin000010001111] & X[0bin000011000000] = 0bin0); +ASSERT (X[0bin000010001111] & X[0bin000011000001] = 0bin0); +ASSERT (X[0bin000010001111] & X[0bin000011000010] = 0bin0); +ASSERT (X[0bin000010001111] & X[0bin000011000011] = 0bin0); +ASSERT (X[0bin000010001111] & X[0bin000011000100] = 0bin0); +ASSERT (X[0bin000010001111] & X[0bin000011000101] = 0bin0); +ASSERT (X[0bin000010001111] & X[0bin000011000110] = 0bin0); +ASSERT (X[0bin000010001111] & X[0bin000011000111] = 0bin0); +ASSERT (X[0bin000010001111] & X[0bin000011001000] = 0bin0); +ASSERT (X[0bin000010001111] & X[0bin000011001001] = 0bin0); +ASSERT (X[0bin000010001111] & X[0bin000011001010] = 0bin0); +ASSERT (X[0bin000010001111] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000010001111] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000010001111] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000010001111] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000010001111] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000010001111] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000010001111] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000010001111] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000010001111] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000010001111] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000010001111] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000010001111] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000010001111] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000010001111] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000010001111] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000010001111] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000010001111] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000010001111] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000010001111] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000010001111] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000010001111] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000010001111] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000010001111] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000010001111] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000010001111] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000010001111] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000010001111] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000010111111] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011000000] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011000001] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011000010] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011000011] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011000100] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011000101] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011000110] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011000111] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011001000] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011001001] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011001010] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011101101] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011101110] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011101111] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011110000] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011110001] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011110010] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011110011] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011110100] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011110101] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011110110] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000010010000] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011000000] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011000001] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011000010] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011000011] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011000100] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011000101] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011000110] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011000111] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011001000] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011001001] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011001010] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011101110] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011101111] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011110000] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011110001] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011110010] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011110011] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011110100] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011110101] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011110110] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100011100] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100011101] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100011110] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100011111] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100100000] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100100001] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100100010] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100100011] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000010010001] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011000001] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011000010] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011000011] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011000100] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011000101] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011000110] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011000111] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011001000] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011001001] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011001010] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011101111] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011110000] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011110001] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011110010] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011110011] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011110100] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011110101] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011110110] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100011101] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100011110] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100011111] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100100000] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100100001] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100100010] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100100011] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000101001011] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000101001100] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000101001101] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000101001110] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000101001111] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000101010000] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000101010001] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000010010010] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000011000010] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000011000011] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000011000100] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000011000101] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000011000110] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000011000111] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000011001000] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000011001001] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000011001010] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000011110000] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000011110001] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000011110010] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000011110011] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000011110100] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000011110101] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000011110110] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100011110] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100011111] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100100000] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100100001] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100100010] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100100011] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000101001100] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000101001101] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000101001110] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000101001111] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000101010000] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000101010001] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000101111010] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000101111011] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000101111100] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000101111101] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000101111110] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000101111111] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000010010011] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000011000011] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000011000100] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000011000101] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000011000110] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000011000111] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000011001000] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000011001001] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000011001010] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000011110001] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000011110010] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000011110011] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000011110100] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000011110101] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000011110110] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100011111] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100100000] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100100001] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100100010] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100100011] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000101001101] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000101001110] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000101001111] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000101010000] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000101010001] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000101111011] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000101111100] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000101111101] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000101111110] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000101111111] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110101001] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110101010] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110101011] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110101100] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110101101] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000010010100] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000011000100] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000011000101] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000011000110] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000011000111] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000011001000] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000011001001] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000011001010] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000011110010] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000011110011] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000011110100] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000011110101] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000011110110] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000100100000] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000100100001] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000100100010] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000100100011] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000101001110] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000101001111] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000101010000] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000101010001] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000101111100] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000101111101] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000101111110] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000101111111] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000110101010] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000110101011] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000110101100] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000110101101] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000111011000] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000111011001] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000111011010] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000111011011] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000111011100] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000010010101] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000011000101] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000011000110] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000011000111] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000011001000] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000011001001] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000011001010] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000011110011] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000011110100] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000011110101] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000011110110] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000100100001] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000100100010] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000100100011] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000101001111] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000101010000] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000101010001] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000101111101] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000101111110] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000101111111] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000110101011] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000110101100] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000110101101] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000111011001] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000111011010] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000111011011] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000111011100] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin001000000111] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin001000001000] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin001000001001] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin001000001010] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000010010110] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000011000110] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000011000111] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000011001000] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000011001001] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000011001010] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000011110100] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000011110101] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000011110110] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000100100010] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000100100011] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000101010000] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000101010001] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000101111110] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000101111111] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000110101100] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000110101101] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000111011010] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000111011011] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000111011100] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001000001000] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001000001001] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001000001010] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001000110110] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001000110111] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001000111000] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001000111001] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000010010111] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000011000111] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000011001000] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000011001001] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000011001010] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000011110101] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000011110110] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000100100011] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000101010001] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000101111111] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000110101101] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000111011011] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000111011100] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001000001001] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001000001010] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001000110111] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001000111000] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001000111001] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001001100101] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001001100110] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001001100111] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001001101000] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000010011000] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000011001000] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000011001001] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000011001010] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000011110110] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000111011100] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001000001010] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001000111000] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001000111001] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001001100110] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001001100111] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001001101000] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001010010100] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001010010101] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001010010110] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000010011001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000011001001] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000011001010] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001000111001] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001001100111] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001001101000] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001010010101] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001010010110] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001011000011] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001011000100] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001011000101] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000010011010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000011001010] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001001101000] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001010010110] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001011000100] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001011000101] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001011110010] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001011110011] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001011110100] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000010011011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000011001011] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001011000101] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001011110011] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001011110100] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001100100001] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001100100010] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001100100011] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000010011100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000011001100] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001011110100] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001100100010] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001100100011] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001101010000] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001101010001] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000010011101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000011001101] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001100100011] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001101010001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001101111111] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001110000000] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000010011110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000011001110] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001110000000] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001110101110] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001110101111] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000010011111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000011001111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001110101111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001111011101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001111011110] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000010100000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000011010000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001111011110] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin010000001100] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin010000001101] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000010100001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000011010001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin010000001101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin010000111011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin010000111100] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000010100010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000011010010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010000111100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010001101010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010001101011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000010100011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000011010011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010001101011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010010011001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010010011010] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000010100100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000011010100] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010010011010] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010011001000] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010011001001] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000010100101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000011010101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010011001001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010011110111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000010100110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000011010110] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010100100110] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000010100111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000011010111] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010101010101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000010101000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000011011000] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010110000100] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000010101001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000011011001] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010110110011] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000010101010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000011011010] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010111100010] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000010101011] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000011011011] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin011000010001] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000010101100] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000011011100] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin011001000000] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000010101101] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000011011101] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin011001101111] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000010101110] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000011011110] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin011010011110] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000010101111] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin000011011111] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin011011001101] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000010110000] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin000011100000] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin011011111100] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000010110001] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin000011100001] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin011100101011] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin000010110010] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin000011100010] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin011101011010] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin000010110011] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin000011100011] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin011110001001] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin000010110100] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin000011100100] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin011110111000] = 0bin0); +ASSERT (X[0bin000010110101] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin000010110110] & X[0bin000011100101] = 0bin0); +ASSERT (X[0bin000010110110] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000010110110] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000010110110] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000010110110] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000010110110] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000010110110] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000010110110] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000010110110] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000010110110] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000010110110] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000010110110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000010110110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000010110110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000010110110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000010110110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000010110110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000010110110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000010110110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000010110110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000010110110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000010110110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000010110110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000010110110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000010110110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000010110110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000010110110] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000010110110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000010110110] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000010110110] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000010110110] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000010110110] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000010110110] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000010110110] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000010110110] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000010110110] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000010110110] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin000010110110] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin000010110110] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin000010110110] & X[0bin011111100111] = 0bin0); +ASSERT (X[0bin000010111110] & X[0bin000011101101] = 0bin0); +ASSERT (X[0bin000010111110] & X[0bin000011101110] = 0bin0); +ASSERT (X[0bin000010111110] & X[0bin000011101111] = 0bin0); +ASSERT (X[0bin000010111110] & X[0bin000011110000] = 0bin0); +ASSERT (X[0bin000010111110] & X[0bin000011110001] = 0bin0); +ASSERT (X[0bin000010111110] & X[0bin000011110010] = 0bin0); +ASSERT (X[0bin000010111110] & X[0bin000011110011] = 0bin0); +ASSERT (X[0bin000010111110] & X[0bin000011110100] = 0bin0); +ASSERT (X[0bin000010111110] & X[0bin000011110101] = 0bin0); +ASSERT (X[0bin000010111110] & X[0bin000011110110] = 0bin0); +ASSERT (X[0bin000010111110] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000010111110] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000010111110] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000010111110] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000010111110] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000010111110] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000010111110] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000010111110] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000010111110] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000010111110] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000010111110] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000010111110] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000010111110] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000010111110] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000010111110] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000010111110] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000010111110] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000010111110] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000010111110] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000010111110] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000010111110] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000010111110] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000010111110] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000010111110] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000010111110] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000010111110] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000010111110] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000010111110] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000010111110] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000011101110] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000011101111] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000011110000] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000011110001] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000011110010] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000011110011] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000011110100] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000011110101] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000011110110] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100011100] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100011101] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100011110] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100011111] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100100000] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100100001] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100100010] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100100011] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000010111111] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000011101111] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000011110000] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000011110001] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000011110010] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000011110011] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000011110100] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000011110101] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000011110110] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100011101] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100011110] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100011111] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100100000] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100100001] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100100010] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100100011] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000101001011] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000101001100] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000101001101] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000101001110] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000101001111] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000101010000] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000101010001] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011000000] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000011110000] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000011110001] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000011110010] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000011110011] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000011110100] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000011110101] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000011110110] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100011110] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100011111] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100100000] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100100001] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100100010] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100100011] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000101001100] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000101001101] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000101001110] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000101001111] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000101010000] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000101010001] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000101111010] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000101111011] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000101111100] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000101111101] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000101111110] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000101111111] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000011000001] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000011110001] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000011110010] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000011110011] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000011110100] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000011110101] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000011110110] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100011111] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100100000] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100100001] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100100010] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100100011] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000101001101] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000101001110] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000101001111] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000101010000] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000101010001] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000101111011] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000101111100] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000101111101] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000101111110] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000101111111] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110101001] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110101010] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110101011] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110101100] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110101101] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000011000010] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000011110010] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000011110011] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000011110100] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000011110101] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000011110110] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000100100000] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000100100001] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000100100010] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000100100011] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000101001110] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000101001111] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000101010000] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000101010001] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000101111100] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000101111101] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000101111110] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000101111111] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000110101010] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000110101011] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000110101100] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000110101101] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000111011000] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000111011001] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000111011010] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000111011011] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000111011100] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000011000011] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000011110011] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000011110100] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000011110101] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000011110110] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000100100001] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000100100010] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000100100011] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000101001111] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000101010000] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000101010001] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000101111101] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000101111110] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000101111111] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000110101011] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000110101100] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000110101101] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000111011001] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000111011010] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000111011011] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000111011100] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin001000000111] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin001000001000] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin001000001001] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin001000001010] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000011000100] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000011110100] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000011110101] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000011110110] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000100100010] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000100100011] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000101010000] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000101010001] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000101111110] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000101111111] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000110101100] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000110101101] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000111011010] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000111011011] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000111011100] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001000001000] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001000001001] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001000001010] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001000110110] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001000110111] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001000111000] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001000111001] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000011000101] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000011110101] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000011110110] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000100100011] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000101010001] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000101111111] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000110101101] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000111011011] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000111011100] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001000001001] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001000001010] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001000110111] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001000111000] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001000111001] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001001100101] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001001100110] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001001100111] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001001101000] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000011000110] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000011110110] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000111011100] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001000001010] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001000111000] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001000111001] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001001100110] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001001100111] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001001101000] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001010010100] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001010010101] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001010010110] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000011000111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000011110111] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001000111001] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001001100111] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001001101000] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001010010101] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001010010110] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001011000011] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001011000100] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001011000101] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000011001000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000011111000] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001001101000] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001010010110] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001011000100] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001011000101] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001011110010] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001011110011] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001011110100] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000011001001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000011111001] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001011000101] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001011110011] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001011110100] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001100100001] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001100100010] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001100100011] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000011001010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000011111010] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001011110100] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001100100010] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001100100011] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001101010000] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001101010001] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000011001011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000011111011] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001100100011] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001101010001] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001101111111] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001110000000] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000011001100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000011111100] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001110000000] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001110101110] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001110101111] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000011001101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000011111101] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001110101111] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001111011101] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001111011110] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000011001110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000011111110] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001111011110] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin010000001100] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin010000001101] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000011001111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000011111111] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin010000001101] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin010000111011] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin010000111100] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000011010000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000100000000] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010000111100] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010001101010] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010001101011] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000011010001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000100000001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010001101011] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010010011001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010010011010] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000011010010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000100000010] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010010011010] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010011001000] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010011001001] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000011010011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000100000011] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010011001001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010011110111] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000011010100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000100000100] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010100100110] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000011010101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000100000101] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010101010101] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000011010110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000100000110] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010110000100] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000011010111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000100000111] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010110110011] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000011011000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000100001000] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010111100010] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000011011001] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000100001001] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin011000010001] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000011011010] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000100001010] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin011001000000] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000011011011] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000100001011] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin011001101111] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000011011100] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin000100001100] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin011010011110] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000011011101] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin000100001101] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin011011001101] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000011011110] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin000100001110] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin011011111100] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000011011111] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin000100001111] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin011100101011] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin000011100000] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin000100010000] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin011101011010] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin000011100001] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin000100010001] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin011110001001] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin000011100010] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin000100010010] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin011110111000] = 0bin0); +ASSERT (X[0bin000011100011] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin000011100100] & X[0bin000100010011] = 0bin0); +ASSERT (X[0bin000011100100] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011100100] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011100100] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011100100] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000011100100] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000011100100] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000011100100] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000011100100] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000011100100] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000011100100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000011100100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000011100100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000011100100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000011100100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000011100100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000011100100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000011100100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000011100100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000011100100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000011100100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000011100100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000011100100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000011100100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000011100100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000011100100] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000011100100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000011100100] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000011100100] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000011100100] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000011100100] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000011100100] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000011100100] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000011100100] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000011100100] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000011100100] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin000011100100] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin000011100100] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin000011100100] & X[0bin011111100111] = 0bin0); +ASSERT (X[0bin000011101101] & X[0bin000100011100] = 0bin0); +ASSERT (X[0bin000011101101] & X[0bin000100011101] = 0bin0); +ASSERT (X[0bin000011101101] & X[0bin000100011110] = 0bin0); +ASSERT (X[0bin000011101101] & X[0bin000100011111] = 0bin0); +ASSERT (X[0bin000011101101] & X[0bin000100100000] = 0bin0); +ASSERT (X[0bin000011101101] & X[0bin000100100001] = 0bin0); +ASSERT (X[0bin000011101101] & X[0bin000100100010] = 0bin0); +ASSERT (X[0bin000011101101] & X[0bin000100100011] = 0bin0); +ASSERT (X[0bin000011101101] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000011101101] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000011101101] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000011101101] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000011101101] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000011101101] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000011101101] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000011101101] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000011101101] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000011101101] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000011101101] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000011101101] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000011101101] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000011101101] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000011101101] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000011101101] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000011101101] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000011101101] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000011101101] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000011101101] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000011101101] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000011101101] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000011101101] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000011101101] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000011101101] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000011101101] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000011101101] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011101101] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011101101] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011101101] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000100011101] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000100011110] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000100011111] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000100100000] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000100100001] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000100100010] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000100100011] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000101001011] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000101001100] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000101001101] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000101001110] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000101001111] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000101010000] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000101010001] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011101110] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000100011110] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000100011111] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000100100000] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000100100001] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000100100010] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000100100011] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000101001100] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000101001101] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000101001110] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000101001111] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000101010000] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000101010001] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000101111010] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000101111011] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000101111100] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000101111101] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000101111110] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000101111111] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000011101111] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000100011111] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000100100000] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000100100001] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000100100010] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000100100011] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000101001101] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000101001110] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000101001111] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000101010000] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000101010001] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000101111011] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000101111100] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000101111101] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000101111110] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000101111111] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110101001] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110101010] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110101011] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110101100] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110101101] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000011110000] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000100100000] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000100100001] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000100100010] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000100100011] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000101001110] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000101001111] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000101010000] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000101010001] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000101111100] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000101111101] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000101111110] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000101111111] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000110101010] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000110101011] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000110101100] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000110101101] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000111011000] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000111011001] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000111011010] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000111011011] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000111011100] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000011110001] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000100100001] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000100100010] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000100100011] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000101001111] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000101010000] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000101010001] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000101111101] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000101111110] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000101111111] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000110101011] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000110101100] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000110101101] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000111011001] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000111011010] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000111011011] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000111011100] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin001000000111] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin001000001000] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin001000001001] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin001000001010] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000011110010] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000100100010] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000100100011] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000101010000] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000101010001] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000101111110] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000101111111] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000110101100] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000110101101] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000111011010] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000111011011] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000111011100] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001000001000] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001000001001] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001000001010] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001000110110] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001000110111] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001000111000] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001000111001] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000011110011] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000100100011] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000101010001] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000101111111] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000110101101] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000111011011] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000111011100] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001000001001] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001000001010] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001000110111] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001000111000] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001000111001] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001001100101] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001001100110] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001001100111] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001001101000] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000011110100] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000100100100] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000111011100] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001000001010] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001000111000] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001000111001] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001001100110] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001001100111] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001001101000] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001010010100] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001010010101] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001010010110] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000011110101] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000100100101] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001000111001] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001001100111] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001001101000] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001010010101] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001010010110] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001011000011] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001011000100] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001011000101] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000011110110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000100100110] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001001101000] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001010010110] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001011000100] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001011000101] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001011110010] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001011110011] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001011110100] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000011110111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000100100111] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001011000101] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001011110011] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001011110100] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001100100001] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001100100010] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001100100011] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000011111000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000100101000] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001011110100] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001100100010] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001100100011] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001101010000] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001101010001] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000011111001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000100101001] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001100100011] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001101010001] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001101111111] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001110000000] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000011111010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000100101010] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001110000000] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001110101110] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001110101111] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000011111011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000100101011] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001110101111] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001111011101] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001111011110] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000011111100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000100101100] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001111011110] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin010000001100] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin010000001101] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000011111101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000100101101] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin010000001101] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin010000111011] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin010000111100] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000011111110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000100101110] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010000111100] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010001101010] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010001101011] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000011111111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000100101111] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010001101011] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010010011001] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010010011010] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000100000000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000100110000] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010010011010] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010011001000] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010011001001] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000100000001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000100110001] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010011001001] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010011110111] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000100000010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000100110010] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010100100110] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000100000011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000100110011] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010101010101] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000100000100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000100110100] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010110000100] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000100000101] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000100110101] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010110110011] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000100000110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000100110110] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010111100010] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000100000111] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000100110111] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin011000010001] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000100001000] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin000100111000] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin011001000000] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000100001001] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin000100111001] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin011001101111] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000100001010] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin000100111010] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin011010011110] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000100001011] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin000100111011] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin011011001101] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000100001100] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin000100111100] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin011011111100] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000100001101] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin000100111101] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin011100101011] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin000100001110] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin000100111110] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin011101011010] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin000100001111] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin000100111111] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin011110001001] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin000100010000] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin000101000000] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin011110111000] = 0bin0); +ASSERT (X[0bin000100010001] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin000100010010] & X[0bin000101000001] = 0bin0); +ASSERT (X[0bin000100010010] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100010010] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100010010] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100010010] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000100010010] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000100010010] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000100010010] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000100010010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000100010010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000100010010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000100010010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000100010010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000100010010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000100010010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000100010010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000100010010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000100010010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000100010010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000100010010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000100010010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000100010010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000100010010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000100010010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000100010010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000100010010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000100010010] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000100010010] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000100010010] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000100010010] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000100010010] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000100010010] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000100010010] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000100010010] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000100010010] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin000100010010] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin000100010010] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin000100010010] & X[0bin011111100111] = 0bin0); +ASSERT (X[0bin000100011100] & X[0bin000101001011] = 0bin0); +ASSERT (X[0bin000100011100] & X[0bin000101001100] = 0bin0); +ASSERT (X[0bin000100011100] & X[0bin000101001101] = 0bin0); +ASSERT (X[0bin000100011100] & X[0bin000101001110] = 0bin0); +ASSERT (X[0bin000100011100] & X[0bin000101001111] = 0bin0); +ASSERT (X[0bin000100011100] & X[0bin000101010000] = 0bin0); +ASSERT (X[0bin000100011100] & X[0bin000101010001] = 0bin0); +ASSERT (X[0bin000100011100] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000100011100] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000100011100] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000100011100] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000100011100] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000100011100] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000100011100] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000100011100] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000100011100] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000100011100] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000100011100] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000100011100] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000100011100] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000100011100] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000100011100] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000100011100] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000100011100] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000100011100] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000100011100] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000100011100] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000100011100] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000100011100] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000100011100] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000100011100] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000100011100] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000100011100] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000100011100] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000100011100] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000100011100] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100011100] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000101001100] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000101001101] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000101001110] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000101001111] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000101010000] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000101010001] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000101111010] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000101111011] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000101111100] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000101111101] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000101111110] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000101111111] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100011101] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000101001101] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000101001110] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000101001111] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000101010000] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000101010001] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000101111011] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000101111100] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000101111101] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000101111110] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000101111111] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110101001] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110101010] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110101011] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110101100] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110101101] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000100011110] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000101001110] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000101001111] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000101010000] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000101010001] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000101111100] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000101111101] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000101111110] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000101111111] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000110101010] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000110101011] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000110101100] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000110101101] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000111011000] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000111011001] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000111011010] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000111011011] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000111011100] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000100011111] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000101001111] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000101010000] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000101010001] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000101111101] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000101111110] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000101111111] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000110101011] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000110101100] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000110101101] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000111011001] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000111011010] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000111011011] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000111011100] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin001000000111] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin001000001000] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin001000001001] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin001000001010] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000100100000] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000101010000] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000101010001] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000101111110] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000101111111] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000110101100] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000110101101] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000111011010] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000111011011] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000111011100] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001000001000] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001000001001] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001000001010] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001000110110] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001000110111] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001000111000] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001000111001] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000100100001] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000101010001] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000101111111] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000110101101] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000111011011] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000111011100] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001000001001] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001000001010] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001000110111] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001000111000] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001000111001] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001001100101] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001001100110] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001001100111] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001001101000] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000100100010] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000101010010] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000111011100] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001000001010] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001000111000] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001000111001] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001001100110] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001001100111] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001001101000] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001010010100] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001010010101] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001010010110] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000100100011] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000101010011] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001000111001] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001001100111] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001001101000] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001010010101] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001010010110] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001011000011] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001011000100] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001011000101] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000100100100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000101010100] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001001101000] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001010010110] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001011000100] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001011000101] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001011110010] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001011110011] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001011110100] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000100100101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000101010101] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001011000101] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001011110011] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001011110100] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001100100001] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001100100010] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001100100011] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000100100110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000101010110] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001011110100] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001100100010] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001100100011] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001101010000] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001101010001] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000100100111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000101010111] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001100100011] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001101010001] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001101111111] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001110000000] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000100101000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000101011000] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001110000000] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001110101110] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001110101111] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000100101001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000101011001] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001110101111] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001111011101] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001111011110] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000100101010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000101011010] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001111011110] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin010000001100] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin010000001101] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000100101011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000101011011] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin010000001101] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin010000111011] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin010000111100] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000100101100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000101011100] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010000111100] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010001101010] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010001101011] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000100101101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000101011101] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010001101011] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010010011001] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010010011010] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000100101110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000101011110] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010010011010] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010011001000] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010011001001] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000100101111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000101011111] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010011001001] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010011110111] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000100110000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000101100000] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010100100110] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000100110001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000101100001] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010101010101] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000100110010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000101100010] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010110000100] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000100110011] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin000101100011] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010110110011] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000100110100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin000101100100] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010111100010] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000100110101] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin000101100101] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin011000010001] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000100110110] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin000101100110] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin011001000000] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000100110111] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin000101100111] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin011001101111] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000100111000] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin000101101000] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin011010011110] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000100111001] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin000101101001] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin011011001101] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000100111010] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin000101101010] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin011011111100] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000100111011] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin000101101011] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin011100101011] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin000100111100] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin000101101100] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin011101011010] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin000100111101] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin000101101101] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin011110001001] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin000100111110] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin000101101110] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin011110111000] = 0bin0); +ASSERT (X[0bin000100111111] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin000101000000] & X[0bin000101101111] = 0bin0); +ASSERT (X[0bin000101000000] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000101000000] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000101000000] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000101000000] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000101000000] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000101000000] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000101000000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000101000000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000101000000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000101000000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000101000000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000101000000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000101000000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000101000000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000101000000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000101000000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000101000000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000101000000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000101000000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000101000000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000101000000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000101000000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000101000000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000101000000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000101000000] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000101000000] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000101000000] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000101000000] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000101000000] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000101000000] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000101000000] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000101000000] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000101000000] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin000101000000] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin000101000000] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin000101000000] & X[0bin011111100111] = 0bin0); +ASSERT (X[0bin000101001011] & X[0bin000101111010] = 0bin0); +ASSERT (X[0bin000101001011] & X[0bin000101111011] = 0bin0); +ASSERT (X[0bin000101001011] & X[0bin000101111100] = 0bin0); +ASSERT (X[0bin000101001011] & X[0bin000101111101] = 0bin0); +ASSERT (X[0bin000101001011] & X[0bin000101111110] = 0bin0); +ASSERT (X[0bin000101001011] & X[0bin000101111111] = 0bin0); +ASSERT (X[0bin000101001011] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000101001011] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000101001011] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000101001011] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000101001011] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000101001011] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000101001011] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000101001011] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000101001011] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000101001011] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000101001011] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000101001011] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000101001011] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000101001011] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000101001011] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000101001011] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000101001011] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000101001011] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000101001011] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000101001011] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000101001011] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000101001011] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000101001011] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000101001011] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000101001011] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000101001011] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000101001011] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000101001011] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000101001011] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000101001011] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000101111011] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000101111100] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000101111101] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000101111110] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000101111111] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110101001] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110101010] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110101011] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110101100] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110101101] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000101001100] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000101111100] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000101111101] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000101111110] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000101111111] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000110101010] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000110101011] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000110101100] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000110101101] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000111011000] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000111011001] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000111011010] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000111011011] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000111011100] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000101001101] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000101111101] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000101111110] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000101111111] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000110101011] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000110101100] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000110101101] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000111011001] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000111011010] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000111011011] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000111011100] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin001000000111] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin001000001000] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin001000001001] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin001000001010] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000101001110] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000101111110] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000101111111] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000110101100] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000110101101] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000111011010] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000111011011] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000111011100] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001000001000] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001000001001] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001000001010] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001000110110] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001000110111] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001000111000] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001000111001] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000101001111] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000101111111] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000110101101] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000111011011] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000111011100] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001000001001] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001000001010] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001000110111] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001000111000] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001000111001] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001001100101] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001001100110] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001001100111] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001001101000] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000101010000] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000110000000] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000111011100] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001000001010] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001000111000] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001000111001] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001001100110] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001001100111] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001001101000] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001010010100] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001010010101] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001010010110] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000101010001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000110000001] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001000111001] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001001100111] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001001101000] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001010010101] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001010010110] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001011000011] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001011000100] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001011000101] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000101010010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000110000010] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001001101000] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001010010110] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001011000100] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001011000101] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001011110010] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001011110011] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001011110100] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000101010011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000110000011] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001011000101] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001011110011] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001011110100] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001100100001] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001100100010] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001100100011] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000101010100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000110000100] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001011110100] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001100100010] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001100100011] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001101010000] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001101010001] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000101010101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000110000101] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001100100011] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001101010001] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001101111111] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001110000000] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000101010110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000110000110] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001110000000] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001110101110] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001110101111] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000101010111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000110000111] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001110101111] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001111011101] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001111011110] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000101011000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000110001000] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001111011110] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin010000001100] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin010000001101] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000101011001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000110001001] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin010000001101] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin010000111011] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin010000111100] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000101011010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000110001010] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010000111100] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010001101010] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010001101011] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000101011011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000110001011] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010001101011] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010010011001] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010010011010] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000101011100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000110001100] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010010011010] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010011001000] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010011001001] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000101011101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin000110001101] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010011001001] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010011110111] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000101011110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin000110001110] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010100100110] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000101011111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin000110001111] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010101010101] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000101100000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin000110010000] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010110000100] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000101100001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin000110010001] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010110110011] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000101100010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin000110010010] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010111100010] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000101100011] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin000110010011] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin011000010001] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000101100100] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin000110010100] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin011001000000] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000101100101] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin000110010101] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin011001101111] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000101100110] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin000110010110] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin011010011110] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000101100111] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin000110010111] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin011011001101] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000101101000] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin000110011000] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin011011111100] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000101101001] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin000110011001] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin011100101011] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin000101101010] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin000110011010] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin011101011010] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin000101101011] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin000110011011] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin011110001001] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin000101101100] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin000110011100] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin011110111000] = 0bin0); +ASSERT (X[0bin000101101101] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin000101101110] & X[0bin000110011101] = 0bin0); +ASSERT (X[0bin000101101110] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000101101110] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000101101110] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000101101110] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000101101110] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000101101110] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000101101110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000101101110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000101101110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000101101110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000101101110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000101101110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000101101110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000101101110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000101101110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000101101110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000101101110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000101101110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000101101110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000101101110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000101101110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000101101110] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000101101110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000101101110] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000101101110] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000101101110] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000101101110] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000101101110] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000101101110] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000101101110] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000101101110] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000101101110] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin000101101110] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin000101101110] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin000101101110] & X[0bin011111100111] = 0bin0); +ASSERT (X[0bin000101111010] & X[0bin000110101001] = 0bin0); +ASSERT (X[0bin000101111010] & X[0bin000110101010] = 0bin0); +ASSERT (X[0bin000101111010] & X[0bin000110101011] = 0bin0); +ASSERT (X[0bin000101111010] & X[0bin000110101100] = 0bin0); +ASSERT (X[0bin000101111010] & X[0bin000110101101] = 0bin0); +ASSERT (X[0bin000101111010] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000101111010] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000101111010] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000101111010] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000101111010] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000101111010] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000101111010] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000101111010] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000101111010] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000101111010] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000101111010] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000101111010] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000101111010] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000101111010] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000101111010] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000101111010] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000101111010] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000101111010] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000101111010] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000101111010] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000101111010] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000101111010] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000101111010] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000101111010] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000101111010] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000101111010] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000101111010] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000101111010] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000101111010] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000101111010] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000110101010] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000110101011] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000110101100] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000110101101] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000111011000] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000111011001] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000111011010] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000111011011] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000111011100] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000101111011] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000110101011] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000110101100] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000110101101] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000111011001] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000111011010] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000111011011] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000111011100] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin001000000111] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin001000001000] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin001000001001] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin001000001010] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000101111100] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000110101100] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000110101101] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000111011010] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000111011011] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000111011100] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001000001000] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001000001001] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001000001010] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001000110110] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001000110111] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001000111000] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001000111001] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000101111101] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000110101101] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000111011011] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000111011100] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001000001001] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001000001010] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001000110111] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001000111000] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001000111001] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001001100101] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001001100110] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001001100111] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001001101000] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000101111110] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000110101110] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000111011100] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001000001010] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001000111000] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001000111001] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001001100110] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001001100111] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001001101000] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001010010100] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001010010101] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001010010110] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000101111111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000110101111] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001000111001] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001001100111] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001001101000] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001010010101] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001010010110] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001011000011] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001011000100] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001011000101] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000110000000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000110110000] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001001101000] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001010010110] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001011000100] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001011000101] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001011110010] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001011110011] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001011110100] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000110000001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000110110001] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001011000101] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001011110011] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001011110100] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001100100001] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001100100010] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001100100011] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000110000010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin000110110010] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001011110100] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001100100010] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001100100011] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001101010000] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001101010001] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000110000011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin000110110011] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001100100011] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001101010001] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001101111111] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001110000000] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000110000100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin000110110100] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001110000000] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001110101110] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001110101111] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000110000101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin000110110101] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001110101111] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001111011101] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001111011110] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000110000110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin000110110110] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001111011110] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin010000001100] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin010000001101] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000110000111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin000110110111] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin010000001101] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin010000111011] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin010000111100] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000110001000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin000110111000] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010000111100] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010001101010] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010001101011] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000110001001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin000110111001] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010001101011] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010010011001] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010010011010] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000110001010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin000110111010] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010010011010] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010011001000] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010011001001] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000110001011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin000110111011] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010011001001] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010011110111] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000110001100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin000110111100] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010100100110] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000110001101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin000110111101] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010101010101] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000110001110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin000110111110] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010110000100] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000110001111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin000110111111] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010110110011] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000110010000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin000111000000] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010111100010] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000110010001] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin000111000001] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin011000010001] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000110010010] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin000111000010] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin011001000000] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000110010011] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin000111000011] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin011001101111] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000110010100] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin000111000100] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin011010011110] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000110010101] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin000111000101] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin011011001101] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000110010110] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin000111000110] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin011011111100] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000110010111] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin000111000111] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin011100101011] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin000110011000] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin000111001000] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin011101011010] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin000110011001] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin000111001001] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin011110001001] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin000110011010] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin000111001010] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin011110111000] = 0bin0); +ASSERT (X[0bin000110011011] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin000110011100] & X[0bin000111001011] = 0bin0); +ASSERT (X[0bin000110011100] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000110011100] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000110011100] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000110011100] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000110011100] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000110011100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000110011100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000110011100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000110011100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000110011100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000110011100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000110011100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000110011100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000110011100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000110011100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000110011100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000110011100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000110011100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000110011100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000110011100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000110011100] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000110011100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000110011100] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000110011100] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000110011100] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000110011100] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000110011100] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000110011100] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000110011100] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000110011100] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000110011100] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin000110011100] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin000110011100] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin000110011100] & X[0bin011111100111] = 0bin0); +ASSERT (X[0bin000110101001] & X[0bin000111011000] = 0bin0); +ASSERT (X[0bin000110101001] & X[0bin000111011001] = 0bin0); +ASSERT (X[0bin000110101001] & X[0bin000111011010] = 0bin0); +ASSERT (X[0bin000110101001] & X[0bin000111011011] = 0bin0); +ASSERT (X[0bin000110101001] & X[0bin000111011100] = 0bin0); +ASSERT (X[0bin000110101001] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000110101001] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000110101001] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000110101001] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000110101001] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000110101001] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000110101001] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000110101001] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000110101001] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000110101001] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000110101001] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000110101001] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000110101001] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000110101001] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000110101001] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000110101001] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000110101001] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000110101001] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000110101001] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000110101001] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000110101001] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000110101001] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000110101001] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000110101001] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000110101001] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000110101001] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000110101001] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000110101001] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000110101001] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin000111011001] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin000111011010] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin000111011011] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin000111011100] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin001000000111] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin001000001000] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin001000001001] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin001000001010] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000110101010] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin000111011010] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin000111011011] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin000111011100] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001000001000] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001000001001] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001000001010] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001000110110] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001000110111] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001000111000] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001000111001] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000110101011] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin000111011011] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin000111011100] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001000001001] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001000001010] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001000110111] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001000111000] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001000111001] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001001100101] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001001100110] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001001100111] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001001101000] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000110101100] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin000111011100] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001000001010] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001000111000] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001000111001] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001001100110] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001001100111] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001001101000] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001010010100] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001010010101] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001010010110] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000110101101] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin000111011101] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001000111001] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001001100111] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001001101000] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001010010101] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001010010110] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001011000011] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001011000100] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001011000101] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000110101110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin000111011110] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001001101000] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001010010110] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001011000100] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001011000101] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001011110010] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001011110011] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001011110100] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000110101111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin000111011111] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001011000101] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001011110011] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001011110100] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001100100001] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001100100010] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001100100011] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000110110000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin000111100000] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001011110100] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001100100010] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001100100011] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001101010000] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001101010001] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000110110001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin000111100001] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001100100011] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001101010001] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001101111111] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001110000000] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000110110010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin000111100010] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001110000000] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001110101110] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001110101111] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000110110011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin000111100011] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001110101111] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001111011101] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001111011110] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000110110100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin000111100100] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001111011110] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin010000001100] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin010000001101] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000110110101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin000111100101] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin010000001101] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin010000111011] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin010000111100] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000110110110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin000111100110] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010000111100] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010001101010] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010001101011] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000110110111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin000111100111] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010001101011] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010010011001] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010010011010] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000110111000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin000111101000] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010010011010] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010011001000] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010011001001] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000110111001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin000111101001] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010011001001] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010011110111] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000110111010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin000111101010] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010100100110] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000110111011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin000111101011] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010101010101] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000110111100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin000111101100] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010110000100] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000110111101] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin000111101101] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010110110011] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000110111110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin000111101110] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010111100010] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000110111111] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin000111101111] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin011000010001] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000111000000] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin000111110000] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin011001000000] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000111000001] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin000111110001] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin011001101111] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000111000010] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin000111110010] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin011010011110] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000111000011] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin000111110011] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin011011001101] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000111000100] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin000111110100] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin011011111100] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000111000101] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin000111110101] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin011100101011] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin000111000110] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin000111110110] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin011101011010] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin000111000111] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin000111110111] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin011110001001] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin000111001000] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin000111111000] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin011110111000] = 0bin0); +ASSERT (X[0bin000111001001] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin000111001010] & X[0bin000111111001] = 0bin0); +ASSERT (X[0bin000111001010] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000111001010] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000111001010] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000111001010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000111001010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000111001010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000111001010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000111001010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000111001010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000111001010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000111001010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000111001010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000111001010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000111001010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000111001010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000111001010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000111001010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000111001010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000111001010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000111001010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000111001010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000111001010] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000111001010] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000111001010] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000111001010] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000111001010] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000111001010] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000111001010] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000111001010] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000111001010] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin000111001010] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin000111001010] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin000111001010] & X[0bin011111100111] = 0bin0); +ASSERT (X[0bin000111011000] & X[0bin001000000111] = 0bin0); +ASSERT (X[0bin000111011000] & X[0bin001000001000] = 0bin0); +ASSERT (X[0bin000111011000] & X[0bin001000001001] = 0bin0); +ASSERT (X[0bin000111011000] & X[0bin001000001010] = 0bin0); +ASSERT (X[0bin000111011000] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000111011000] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000111011000] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000111011000] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000111011000] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000111011000] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000111011000] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000111011000] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000111011000] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000111011000] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000111011000] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000111011000] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000111011000] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000111011000] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000111011000] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000111011000] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000111011000] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000111011000] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000111011000] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000111011000] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000111011000] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000111011000] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000111011000] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000111011000] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000111011000] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000111011000] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000111011000] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000111011000] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000111011000] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001000001000] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001000001001] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001000001010] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001000110110] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001000110111] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001000111000] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001000111001] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000111011001] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001000001001] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001000001010] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001000110111] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001000111000] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001000111001] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001001100101] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001001100110] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001001100111] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001001101000] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000111011010] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001000001010] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001000111000] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001000111001] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001001100110] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001001100111] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001001101000] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001010010100] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001010010101] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001010010110] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000111011011] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001000001011] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001000111001] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001001100111] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001001101000] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001010010101] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001010010110] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001011000011] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001011000100] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001011000101] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000111011100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001000001100] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001001101000] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001010010110] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001011000100] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001011000101] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001011110010] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001011110011] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001011110100] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000111011101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001000001101] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001011000101] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001011110011] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001011110100] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001100100001] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001100100010] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001100100011] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000111011110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001000001110] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001011110100] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001100100010] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001100100011] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001101010000] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001101010001] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000111011111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001000001111] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001100100011] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001101010001] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001101111111] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001110000000] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000111100000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001000010000] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001110000000] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001110101110] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001110101111] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000111100001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001000010001] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001110101111] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001111011101] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001111011110] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000111100010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001000010010] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001111011110] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin010000001100] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin010000001101] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000111100011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001000010011] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin010000001101] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin010000111011] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin010000111100] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000111100100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001000010100] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010000111100] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010001101010] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010001101011] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000111100101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001000010101] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010001101011] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010010011001] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010010011010] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000111100110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001000010110] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010010011010] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010011001000] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010011001001] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000111100111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001000010111] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010011001001] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010011110111] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000111101000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001000011000] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010100100110] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000111101001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001000011001] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010101010101] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000111101010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001000011010] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010110000100] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000111101011] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001000011011] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010110110011] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000111101100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001000011100] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010111100010] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000111101101] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001000011101] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin011000010001] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000111101110] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001000011110] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin011001000000] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000111101111] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001000011111] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin011001101111] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000111110000] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001000100000] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin011010011110] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000111110001] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001000100001] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin011011001101] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000111110010] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001000100010] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin011011111100] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000111110011] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001000100011] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin011100101011] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin000111110100] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin001000100100] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin011101011010] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin000111110101] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin001000100101] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin011110001001] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin000111110110] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin001000100110] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin011110111000] = 0bin0); +ASSERT (X[0bin000111110111] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin000111111000] & X[0bin001000100111] = 0bin0); +ASSERT (X[0bin000111111000] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin000111111000] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin000111111000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin000111111000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin000111111000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin000111111000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin000111111000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin000111111000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin000111111000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin000111111000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin000111111000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin000111111000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin000111111000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin000111111000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin000111111000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin000111111000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin000111111000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin000111111000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin000111111000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin000111111000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin000111111000] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin000111111000] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin000111111000] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin000111111000] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin000111111000] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin000111111000] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin000111111000] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin000111111000] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin000111111000] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin000111111000] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin000111111000] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin000111111000] & X[0bin011111100111] = 0bin0); +ASSERT (X[0bin001000000111] & X[0bin001000110110] = 0bin0); +ASSERT (X[0bin001000000111] & X[0bin001000110111] = 0bin0); +ASSERT (X[0bin001000000111] & X[0bin001000111000] = 0bin0); +ASSERT (X[0bin001000000111] & X[0bin001000111001] = 0bin0); +ASSERT (X[0bin001000000111] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin001000000111] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin001000000111] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin001000000111] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin001000000111] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin001000000111] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin001000000111] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin001000000111] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin001000000111] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin001000000111] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin001000000111] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin001000000111] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin001000000111] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin001000000111] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin001000000111] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin001000000111] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin001000000111] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin001000000111] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin001000000111] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin001000000111] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin001000000111] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin001000000111] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin001000000111] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin001000000111] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin001000000111] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin001000000111] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin001000000111] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin001000000111] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001000110111] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001000111000] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001000111001] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001001100101] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001001100110] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001001100111] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001001101000] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001000001000] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001000111000] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001000111001] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001001100110] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001001100111] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001001101000] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001010010100] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001010010101] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001010010110] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001000001001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001000111001] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001001100111] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001001101000] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001010010101] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001010010110] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001011000011] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001011000100] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001011000101] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001000001010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001000111010] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001001101000] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001010010110] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001011000100] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001011000101] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001011110010] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001011110011] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001011110100] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001000001011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001000111011] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001011000101] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001011110011] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001011110100] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001100100001] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001100100010] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001100100011] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001000001100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001000111100] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001011110100] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001100100010] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001100100011] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001101010000] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001101010001] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001000001101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001000111101] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001100100011] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001101010001] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001101111111] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001110000000] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001000001110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001000111110] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001110000000] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001110101110] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001110101111] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001000001111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001000111111] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001110101111] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001111011101] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001111011110] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001000010000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001001000000] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001111011110] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin010000001100] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin010000001101] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001000010001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001001000001] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin010000001101] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin010000111011] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin010000111100] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001000010010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001001000010] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010000111100] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010001101010] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010001101011] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001000010011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001001000011] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010001101011] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010010011001] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010010011010] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001000010100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001001000100] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010010011010] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010011001000] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010011001001] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001000010101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001001000101] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010011001001] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010011110111] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001000010110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001001000110] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010100100110] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001000010111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001001000111] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010101010101] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001000011000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001001001000] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010110000100] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001000011001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001001001001] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010110110011] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001000011010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001001001010] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010111100010] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001000011011] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001001001011] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin011000010001] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001000011100] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001001001100] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin011001000000] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001000011101] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001001001101] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin011001101111] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001000011110] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001001001110] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin011010011110] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001000011111] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001001001111] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin011011001101] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001000100000] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001001010000] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin011011111100] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001000100001] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin001001010001] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin011100101011] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin001000100010] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin001001010010] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin011101011010] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin001000100011] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin001001010011] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin011110001001] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin001000100100] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin001001010100] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin011110111000] = 0bin0); +ASSERT (X[0bin001000100101] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin001000100110] & X[0bin001001010101] = 0bin0); +ASSERT (X[0bin001000100110] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001000100110] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001000100110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001000100110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001000100110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001000100110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001000100110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001000100110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001000100110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001000100110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001000100110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001000100110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001000100110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001000100110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001000100110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001000100110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001000100110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001000100110] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001000100110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001000100110] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001000100110] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001000100110] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001000100110] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001000100110] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001000100110] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001000100110] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001000100110] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001000100110] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin001000100110] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin001000100110] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin001000100110] & X[0bin011111100111] = 0bin0); +ASSERT (X[0bin001000110110] & X[0bin001001100101] = 0bin0); +ASSERT (X[0bin001000110110] & X[0bin001001100110] = 0bin0); +ASSERT (X[0bin001000110110] & X[0bin001001100111] = 0bin0); +ASSERT (X[0bin001000110110] & X[0bin001001101000] = 0bin0); +ASSERT (X[0bin001000110110] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin001000110110] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin001000110110] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin001000110110] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin001000110110] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin001000110110] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin001000110110] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin001000110110] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin001000110110] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin001000110110] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin001000110110] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin001000110110] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin001000110110] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin001000110110] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin001000110110] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin001000110110] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin001000110110] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin001000110110] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin001000110110] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin001000110110] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin001000110110] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin001000110110] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin001000110110] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001000110110] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001000110110] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001000110110] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001000110110] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001001100110] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001001100111] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001001101000] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001010010100] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001010010101] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001010010110] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001000110111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001001100111] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001001101000] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001010010101] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001010010110] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001011000011] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001011000100] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001011000101] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001000111000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001001101000] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001010010110] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001011000100] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001011000101] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001011110010] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001011110011] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001011110100] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001000111001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001001101001] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001011000101] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001011110011] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001011110100] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001100100001] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001100100010] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001100100011] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001000111010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001001101010] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001011110100] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001100100010] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001100100011] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001101010000] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001101010001] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001000111011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001001101011] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001100100011] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001101010001] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001101111111] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001110000000] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001000111100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001001101100] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001110000000] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001110101110] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001110101111] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001000111101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001001101101] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001110101111] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001111011101] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001111011110] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001000111110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001001101110] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001111011110] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin010000001100] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin010000001101] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001000111111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001001101111] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin010000001101] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin010000111011] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin010000111100] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001001000000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001001110000] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010000111100] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010001101010] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010001101011] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001001000001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001001110001] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010001101011] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010010011001] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010010011010] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001001000010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001001110010] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010010011010] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010011001000] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010011001001] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001001000011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001001110011] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010011001001] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010011110111] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001001000100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001001110100] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010100100110] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001001000101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001001110101] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010101010101] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001001000110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001001110110] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010110000100] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001001000111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001001110111] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010110110011] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001001001000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001001111000] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010111100010] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001001001001] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001001111001] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin011000010001] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001001001010] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001001111010] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin011001000000] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001001001011] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001001111011] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin011001101111] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001001001100] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001001111100] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin011010011110] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001001001101] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001001111101] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin011011001101] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001001001110] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001001111110] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin011011111100] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001001001111] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin001001111111] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin011100101011] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin001001010000] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin001010000000] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin011101011010] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin001001010001] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin001010000001] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin011110001001] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin001001010010] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin001010000010] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin011110111000] = 0bin0); +ASSERT (X[0bin001001010011] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin001001010100] & X[0bin001010000011] = 0bin0); +ASSERT (X[0bin001001010100] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001001010100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001001010100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001001010100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001001010100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001001010100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001001010100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001001010100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001001010100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001001010100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001001010100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001001010100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001001010100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001001010100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001001010100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001001010100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001001010100] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001001010100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001001010100] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001001010100] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001001010100] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001001010100] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001001010100] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001001010100] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001001010100] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001001010100] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001001010100] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin001001010100] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin001001010100] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin001001010100] & X[0bin011111100111] = 0bin0); +ASSERT (X[0bin001001100101] & X[0bin001010010100] = 0bin0); +ASSERT (X[0bin001001100101] & X[0bin001010010101] = 0bin0); +ASSERT (X[0bin001001100101] & X[0bin001010010110] = 0bin0); +ASSERT (X[0bin001001100101] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin001001100101] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin001001100101] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin001001100101] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin001001100101] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin001001100101] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin001001100101] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin001001100101] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin001001100101] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin001001100101] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin001001100101] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin001001100101] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin001001100101] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin001001100101] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin001001100101] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001001100101] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001001100101] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001001100101] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001001100101] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001001100101] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001001100101] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001001100101] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001001100101] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001001100101] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001001100101] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001001100101] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001001100101] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001010010101] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001010010110] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001011000011] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001011000100] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001011000101] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001001100110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001010010110] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001011000100] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001011000101] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001011110010] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001011110011] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001011110100] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001001100111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001010010111] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001011000101] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001011110011] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001011110100] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001100100001] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001100100010] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001100100011] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001001101000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001010011000] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001011110100] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001100100010] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001100100011] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001101010000] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001101010001] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001001101001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001010011001] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001100100011] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001101010001] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001101111111] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001110000000] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001001101010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001010011010] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001110000000] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001110101110] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001110101111] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001001101011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001010011011] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001110101111] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001111011101] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001111011110] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001001101100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001010011100] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001111011110] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin010000001100] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin010000001101] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001001101101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001010011101] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin010000001101] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin010000111011] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin010000111100] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001001101110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001010011110] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010000111100] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010001101010] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010001101011] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001001101111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001010011111] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010001101011] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010010011001] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010010011010] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001001110000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001010100000] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010010011010] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010011001000] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010011001001] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001001110001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001010100001] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010011001001] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010011110111] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001001110010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001010100010] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010100100110] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001001110011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001010100011] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010101010101] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001001110100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001010100100] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010110000100] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001001110101] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001010100101] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010110110011] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001001110110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001010100110] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010111100010] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001001110111] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001010100111] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin011000010001] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001001111000] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001010101000] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin011001000000] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001001111001] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001010101001] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin011001101111] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001001111010] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001010101010] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin011010011110] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001001111011] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001010101011] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin011011001101] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001001111100] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin001010101100] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin011011111100] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001001111101] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin001010101101] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin011100101011] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin001001111110] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin001010101110] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin011101011010] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin001001111111] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin001010101111] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin011110001001] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin001010000000] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin001010110000] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin011110111000] = 0bin0); +ASSERT (X[0bin001010000001] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin001010000010] & X[0bin001010110001] = 0bin0); +ASSERT (X[0bin001010000010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001010000010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001010000010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001010000010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001010000010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001010000010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001010000010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001010000010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001010000010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001010000010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001010000010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001010000010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001010000010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001010000010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001010000010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001010000010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001010000010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001010000010] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001010000010] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001010000010] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001010000010] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001010000010] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001010000010] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001010000010] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001010000010] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001010000010] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin001010000010] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin001010000010] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin001010000010] & X[0bin011111100111] = 0bin0); +ASSERT (X[0bin001010010100] & X[0bin001011000011] = 0bin0); +ASSERT (X[0bin001010010100] & X[0bin001011000100] = 0bin0); +ASSERT (X[0bin001010010100] & X[0bin001011000101] = 0bin0); +ASSERT (X[0bin001010010100] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin001010010100] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin001010010100] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin001010010100] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin001010010100] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin001010010100] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin001010010100] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin001010010100] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin001010010100] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin001010010100] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin001010010100] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001010010100] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001010010100] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001010010100] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001010010100] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001010010100] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001010010100] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001010010100] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001010010100] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001010010100] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001010010100] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001010010100] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001010010100] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001010010100] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001010010100] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001010010100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001011000100] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001011000101] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001011110010] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001011110011] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001011110100] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001010010101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001011000101] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001011110011] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001011110100] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001100100001] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001100100010] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001100100011] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001010010110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001011000110] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001011110100] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001100100010] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001100100011] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001101010000] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001101010001] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001010010111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001011000111] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001100100011] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001101010001] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001101111111] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001110000000] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001010011000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001011001000] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001110000000] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001110101110] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001110101111] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001010011001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001011001001] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001110101111] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001111011101] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001111011110] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001010011010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001011001010] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001111011110] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin010000001100] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin010000001101] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001010011011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001011001011] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin010000001101] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin010000111011] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin010000111100] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001010011100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001011001100] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010000111100] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010001101010] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010001101011] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001010011101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001011001101] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010001101011] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010010011001] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010010011010] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001010011110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001011001110] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010010011010] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010011001000] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010011001001] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001010011111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001011001111] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010011001001] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010011110111] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001010100000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001011010000] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010100100110] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001010100001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001011010001] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010101010101] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001010100010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001011010010] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010110000100] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001010100011] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001011010011] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010110110011] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001010100100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001011010100] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010111100010] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001010100101] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001011010101] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin011000010001] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001010100110] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001011010110] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin011001000000] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001010100111] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001011010111] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin011001101111] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001010101000] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001011011000] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin011010011110] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001010101001] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin001011011001] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin011011001101] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001010101010] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin001011011010] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin011011111100] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001010101011] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin001011011011] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin011100101011] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin001010101100] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin001011011100] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin011101011010] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin001010101101] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin001011011101] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin011110001001] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin001010101110] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin001011011110] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin011110111000] = 0bin0); +ASSERT (X[0bin001010101111] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin001010110000] & X[0bin001011011111] = 0bin0); +ASSERT (X[0bin001010110000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001010110000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001010110000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001010110000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001010110000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001010110000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001010110000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001010110000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001010110000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001010110000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001010110000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001010110000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001010110000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001010110000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001010110000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001010110000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001010110000] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001010110000] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001010110000] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001010110000] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001010110000] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001010110000] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001010110000] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001010110000] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001010110000] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin001010110000] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin001010110000] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin001010110000] & X[0bin011111100111] = 0bin0); +ASSERT (X[0bin001011000011] & X[0bin001011110010] = 0bin0); +ASSERT (X[0bin001011000011] & X[0bin001011110011] = 0bin0); +ASSERT (X[0bin001011000011] & X[0bin001011110100] = 0bin0); +ASSERT (X[0bin001011000011] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin001011000011] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin001011000011] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin001011000011] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin001011000011] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin001011000011] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin001011000011] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin001011000011] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001011000011] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001011000011] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001011000011] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001011000011] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001011000011] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001011000011] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001011000011] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001011000011] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001011000011] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001011000011] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001011000011] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001011000011] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001011000011] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001011000011] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001011000011] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001011000011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001011000011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001011110011] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001011110100] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001100100001] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001100100010] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001100100011] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001011000100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001011110100] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001100100010] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001100100011] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001101010000] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001101010001] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001011000101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001011110101] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001100100011] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001101010001] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001101111111] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001110000000] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001011000110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001011110110] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001110000000] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001110101110] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001110101111] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001011000111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001011110111] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001110101111] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001111011101] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001111011110] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001011001000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001011111000] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001111011110] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin010000001100] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin010000001101] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001011001001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001011111001] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin010000001101] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin010000111011] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin010000111100] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001011001010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001011111010] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010000111100] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010001101010] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010001101011] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001011001011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001011111011] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010001101011] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010010011001] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010010011010] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001011001100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001011111100] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010010011010] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010011001000] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010011001001] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001011001101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001011111101] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010011001001] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010011110111] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001011001110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001011111110] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010100100110] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001011001111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001011111111] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010101010101] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001011010000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001100000000] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010110000100] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001011010001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001100000001] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010110110011] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001011010010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001100000010] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010111100010] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001011010011] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001100000011] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin011000010001] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001011010100] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001100000100] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin011001000000] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001011010101] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001100000101] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin011001101111] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001011010110] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin001100000110] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin011010011110] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001011010111] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin001100000111] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin011011001101] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001011011000] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin001100001000] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin011011111100] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001011011001] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin001100001001] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin011100101011] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin001011011010] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin001100001010] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin011101011010] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin001011011011] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin001100001011] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin011110001001] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin001011011100] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin001100001100] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin011110111000] = 0bin0); +ASSERT (X[0bin001011011101] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin001011011110] & X[0bin001100001101] = 0bin0); +ASSERT (X[0bin001011011110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001011011110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001011011110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001011011110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001011011110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001011011110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001011011110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001011011110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001011011110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001011011110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001011011110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001011011110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001011011110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001011011110] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001011011110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001011011110] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001011011110] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001011011110] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001011011110] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001011011110] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001011011110] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001011011110] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001011011110] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001011011110] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin001011011110] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin001011011110] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin001011011110] & X[0bin011111100111] = 0bin0); +ASSERT (X[0bin001011110010] & X[0bin001100100001] = 0bin0); +ASSERT (X[0bin001011110010] & X[0bin001100100010] = 0bin0); +ASSERT (X[0bin001011110010] & X[0bin001100100011] = 0bin0); +ASSERT (X[0bin001011110010] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin001011110010] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin001011110010] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin001011110010] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin001011110010] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin001011110010] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001011110010] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001011110010] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001011110010] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001011110010] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001011110010] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001011110010] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001011110010] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001011110010] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001011110010] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001011110010] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001011110010] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001011110010] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001011110010] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001011110010] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001011110010] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001011110010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001011110010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001011110010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001011110011] & X[0bin001100100010] = 0bin0); +ASSERT (X[0bin001011110011] & X[0bin001100100011] = 0bin0); +ASSERT (X[0bin001011110011] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin001011110011] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin001011110011] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin001011110011] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin001011110011] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin001011110011] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001011110011] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001011110011] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001011110011] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001011110011] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001011110011] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001011110011] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001011110011] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001011110011] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001011110011] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001011110011] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001011110011] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001011110011] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001011110011] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001011110011] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001011110011] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001011110011] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001011110011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001011110011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001011110011] & X[0bin001101010000] = 0bin0); +ASSERT (X[0bin001011110011] & X[0bin001101010001] = 0bin0); +ASSERT (X[0bin001011110011] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin001011110011] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin001011110011] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin001011110011] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin001011110011] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin001011110011] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001011110011] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001011110011] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001011110011] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001011110011] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001011110011] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001011110011] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001011110011] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001011110011] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001011110011] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001011110011] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001011110011] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001011110011] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001011110011] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001011110011] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001011110011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001011110011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001011110011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001011110011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001100100011] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001101010001] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001101111111] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001110000000] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001011110100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001100100100] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001110000000] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001110101110] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001110101111] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001011110101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001100100101] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001110101111] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001111011101] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001111011110] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001011110110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001100100110] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001111011110] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin010000001100] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin010000001101] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001011110111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001100100111] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin010000001101] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin010000111011] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin010000111100] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001011111000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001100101000] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010000111100] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010001101010] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010001101011] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001011111001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001100101001] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010001101011] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010010011001] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010010011010] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001011111010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001100101010] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010010011010] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010011001000] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010011001001] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001011111011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001100101011] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010011001001] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010011110111] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001011111100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001100101100] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010100100110] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001011111101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001100101101] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010101010101] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001011111110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001100101110] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010110000100] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001011111111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001100101111] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010110110011] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001100000000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001100110000] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010111100010] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001100000001] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001100110001] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin011000010001] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001100000010] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin001100110010] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin011001000000] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001100000011] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin001100110011] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin011001101111] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001100000100] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin001100110100] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin011010011110] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001100000101] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin001100110101] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin011011001101] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001100000110] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin001100110110] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin011011111100] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001100000111] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin001100110111] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin011100101011] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin001100001000] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin001100111000] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin011101011010] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin001100001001] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin001100111001] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin011110001001] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin001100001010] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin001100001011] & X[0bin001100111010] = 0bin0); +ASSERT (X[0bin001100001011] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001100001011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001100001011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001100001011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001100001011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001100001011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001100001011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001100001011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001100001011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001100001011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001100001011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001100001011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001100001011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001100001011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001100001011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001100001011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001100001011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001100001011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001100001011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001100001011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001100001011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001100001011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001100001011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001100001011] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001100001011] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001100001011] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001100001011] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001100001011] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001100001011] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001100001011] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001100001011] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001100001011] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001100001011] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001100001011] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001100001011] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001100001011] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001100001011] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001100001011] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001100001011] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001100001011] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001100001011] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001100001011] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001100001011] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001100001011] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin001100001011] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001100001011] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin001100001011] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin001100001011] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin001100001011] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin001100001011] & X[0bin011110111000] = 0bin0); +ASSERT (X[0bin001100001011] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin001100001100] & X[0bin001100111011] = 0bin0); +ASSERT (X[0bin001100001100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001100001100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001100001100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001100001100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001100001100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001100001100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001100001100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001100001100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001100001100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001100001100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001100001100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001100001100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001100001100] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001100001100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001100001100] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001100001100] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001100001100] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001100001100] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001100001100] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001100001100] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001100001100] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001100001100] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001100001100] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin001100001100] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin001100001100] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin001100001100] & X[0bin011111100111] = 0bin0); +ASSERT (X[0bin001100100001] & X[0bin001101010000] = 0bin0); +ASSERT (X[0bin001100100001] & X[0bin001101010001] = 0bin0); +ASSERT (X[0bin001100100001] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin001100100001] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin001100100001] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin001100100001] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin001100100001] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin001100100001] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001100100001] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001100100001] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001100100001] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001100100001] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001100100001] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001100100001] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001100100001] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001100100001] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001100100001] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001100100001] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001100100001] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001100100001] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001100100001] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001100100001] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001100100001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001100100001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001100100001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001100100001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001100100010] & X[0bin001101010001] = 0bin0); +ASSERT (X[0bin001100100010] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin001100100010] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin001100100010] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin001100100010] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin001100100010] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin001100100010] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001100100010] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001100100010] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001100100010] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001100100010] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001100100010] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001100100010] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001100100010] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001100100010] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001100100010] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001100100010] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001100100010] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001100100010] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001100100010] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001100100010] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001100100010] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001100100010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001100100010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001100100010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001100100010] & X[0bin001101111111] = 0bin0); +ASSERT (X[0bin001100100010] & X[0bin001110000000] = 0bin0); +ASSERT (X[0bin001100100010] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin001100100010] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin001100100010] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin001100100010] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin001100100010] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001100100010] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001100100010] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001100100010] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001100100010] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001100100010] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001100100010] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001100100010] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001100100010] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001100100010] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001100100010] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001100100010] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001100100010] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001100100010] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001100100010] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001100100010] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001100100010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001100100010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001100100010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001101010010] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001110000000] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001110101110] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001110101111] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001100100011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001101010011] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001110101111] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001111011101] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001111011110] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001100100100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001101010100] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001111011110] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin010000001100] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin010000001101] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001100100101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001101010101] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin010000001101] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin010000111011] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin010000111100] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001100100110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001101010110] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010000111100] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010001101010] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010001101011] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001100100111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001101010111] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010001101011] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010010011001] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010010011010] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001100101000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001101011000] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010010011010] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010011001000] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010011001001] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001100101001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001101011001] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010011001001] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010011110111] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001100101010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001101011010] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010100100110] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001100101011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001101011011] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010101010101] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001100101100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001101011100] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010110000100] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001100101101] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin001101011101] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010110110011] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001100101110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin001101011110] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010111100010] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001100101111] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin001101011111] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin011000010001] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001100110000] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin001101100000] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin011001000000] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001100110001] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin001101100001] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin011001101111] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001100110010] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin001101100010] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin011010011110] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001100110011] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin001101100011] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin011011001101] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001100110100] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin001101100100] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin011011111100] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001100110101] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin001101100101] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin011100101011] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin001100110110] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin001101100110] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin011101011010] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin001100110111] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin001101100111] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin011110001001] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin001100111000] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin001100111001] & X[0bin001101101000] = 0bin0); +ASSERT (X[0bin001100111001] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001100111001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001100111001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001100111001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001100111001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001100111001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001100111001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001100111001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001100111001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001100111001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001100111001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001100111001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001100111001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001100111001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001100111001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001100111001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001100111001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001100111001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001100111001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001100111001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001100111001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001100111001] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001100111001] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001100111001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001100111001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001100111001] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001100111001] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001100111001] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001100111001] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001100111001] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001100111001] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001100111001] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001100111001] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001100111001] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001100111001] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001100111001] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001100111001] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001100111001] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001100111001] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001100111001] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001100111001] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001100111001] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin001100111001] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001100111001] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin001100111001] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin001100111001] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin001100111001] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin001100111001] & X[0bin011110111000] = 0bin0); +ASSERT (X[0bin001100111001] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin001100111010] & X[0bin001101101001] = 0bin0); +ASSERT (X[0bin001100111010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001100111010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001100111010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001100111010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001100111010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001100111010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001100111010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001100111010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001100111010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001100111010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001100111010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001100111010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001100111010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001100111010] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001100111010] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001100111010] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001100111010] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001100111010] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001100111010] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001100111010] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001100111010] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001100111010] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin001100111010] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin001100111010] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin001100111010] & X[0bin011111100111] = 0bin0); +ASSERT (X[0bin001101010000] & X[0bin001101111111] = 0bin0); +ASSERT (X[0bin001101010000] & X[0bin001110000000] = 0bin0); +ASSERT (X[0bin001101010000] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin001101010000] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin001101010000] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin001101010000] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin001101010000] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001101010000] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001101010000] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001101010000] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001101010000] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001101010000] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001101010000] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001101010000] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001101010000] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001101010000] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001101010000] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001101010000] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001101010000] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001101010000] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001101010000] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001101010000] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001101010000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001101010000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001101010000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001101010001] & X[0bin001110000000] = 0bin0); +ASSERT (X[0bin001101010001] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin001101010001] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin001101010001] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin001101010001] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin001101010001] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001101010001] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001101010001] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001101010001] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001101010001] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001101010001] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001101010001] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001101010001] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001101010001] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001101010001] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001101010001] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001101010001] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001101010001] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001101010001] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001101010001] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001101010001] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001101010001] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001101010001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001101010001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001101010001] & X[0bin001110101110] = 0bin0); +ASSERT (X[0bin001101010001] & X[0bin001110101111] = 0bin0); +ASSERT (X[0bin001101010001] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin001101010001] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin001101010001] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin001101010001] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001101010001] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001101010001] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001101010001] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001101010001] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001101010001] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001101010001] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001101010001] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001101010001] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001101010001] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001101010001] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001101010001] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001101010001] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001101010001] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001101010001] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001101010001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001101010001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001101010001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001101010001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001110000001] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001110101111] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001111011101] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001111011110] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001101010010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001110000010] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001111011110] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin010000001100] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin010000001101] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001101010011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001110000011] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin010000001101] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin010000111011] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin010000111100] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001101010100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001110000100] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010000111100] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010001101010] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010001101011] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001101010101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001110000101] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010001101011] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010010011001] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010010011010] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001101010110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001110000110] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010010011010] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010011001000] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010011001001] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001101010111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin001110000111] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010011001001] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010011110111] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001101011000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin001110001000] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010100100110] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001101011001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin001110001001] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010101010101] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001101011010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin001110001010] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010110000100] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001101011011] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin001110001011] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010110110011] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001101011100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin001110001100] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010111100010] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001101011101] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin001110001101] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin011000010001] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001101011110] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin001110001110] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin011001000000] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001101011111] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin001110001111] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin011001101111] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001101100000] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin001110010000] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin011010011110] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001101100001] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin001110010001] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin011011001101] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001101100010] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin001110010010] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin011011111100] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001101100011] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin001110010011] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin011100101011] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin001101100100] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin001110010100] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin011101011010] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin001101100101] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin001110010101] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin011110001001] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin001101100110] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin001101100111] & X[0bin001110010110] = 0bin0); +ASSERT (X[0bin001101100111] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001101100111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001101100111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001101100111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001101100111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001101100111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001101100111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001101100111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001101100111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001101100111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001101100111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001101100111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001101100111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001101100111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001101100111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001101100111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001101100111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001101100111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001101100111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001101100111] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001101100111] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001101100111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001101100111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001101100111] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001101100111] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001101100111] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001101100111] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001101100111] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001101100111] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001101100111] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001101100111] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001101100111] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001101100111] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001101100111] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001101100111] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001101100111] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001101100111] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001101100111] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001101100111] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001101100111] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin001101100111] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001101100111] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin001101100111] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin001101100111] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin001101100111] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin001101100111] & X[0bin011110111000] = 0bin0); +ASSERT (X[0bin001101100111] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin001101101000] & X[0bin001110010111] = 0bin0); +ASSERT (X[0bin001101101000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001101101000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001101101000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001101101000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001101101000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001101101000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001101101000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001101101000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001101101000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001101101000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001101101000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001101101000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001101101000] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001101101000] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001101101000] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001101101000] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001101101000] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001101101000] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001101101000] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001101101000] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001101101000] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin001101101000] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin001101101000] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin001101101000] & X[0bin011111100111] = 0bin0); +ASSERT (X[0bin001101111111] & X[0bin001110101110] = 0bin0); +ASSERT (X[0bin001101111111] & X[0bin001110101111] = 0bin0); +ASSERT (X[0bin001101111111] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin001101111111] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin001101111111] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin001101111111] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001101111111] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001101111111] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001101111111] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001101111111] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001101111111] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001101111111] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001101111111] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001101111111] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001101111111] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001101111111] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001101111111] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001101111111] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001101111111] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001101111111] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001101111111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001101111111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001101111111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001101111111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001110000000] & X[0bin001110101111] = 0bin0); +ASSERT (X[0bin001110000000] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin001110000000] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin001110000000] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin001110000000] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001110000000] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001110000000] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001110000000] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001110000000] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001110000000] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001110000000] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001110000000] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001110000000] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001110000000] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001110000000] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001110000000] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001110000000] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001110000000] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001110000000] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001110000000] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001110000000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001110000000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001110000000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001110000000] & X[0bin001111011101] = 0bin0); +ASSERT (X[0bin001110000000] & X[0bin001111011110] = 0bin0); +ASSERT (X[0bin001110000000] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin001110000000] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin001110000000] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin001110000000] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001110000000] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001110000000] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001110000000] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001110000000] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001110000000] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001110000000] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001110000000] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001110000000] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001110000000] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001110000000] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001110000000] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001110000000] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001110000000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001110000000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001110000000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001110000000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001110000000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin001110110000] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin001111011110] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin010000001100] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin010000001101] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001110000001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin001110110001] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin010000001101] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin010000111011] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin010000111100] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001110000010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin001110110010] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010000111100] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010001101010] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010001101011] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001110000011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin001110110011] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010001101011] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010010011001] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010010011010] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001110000100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin001110110100] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010010011010] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010011001000] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010011001001] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001110000101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin001110110101] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010011001001] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010011110111] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001110000110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin001110110110] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010100100110] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001110000111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin001110110111] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010101010101] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001110001000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin001110111000] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010110000100] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001110001001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin001110111001] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010110110011] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001110001010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin001110111010] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010111100010] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001110001011] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin001110111011] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin011000010001] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001110001100] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin001110111100] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin011001000000] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001110001101] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin001110111101] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin011001101111] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001110001110] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin001110111110] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin011010011110] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001110001111] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin001110111111] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin011011001101] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001110010000] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin001111000000] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin011011111100] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001110010001] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin001111000001] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin011100101011] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin001110010010] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin001111000010] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin011101011010] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin001110010011] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin001111000011] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin011110001001] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin001110010100] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin001110010101] & X[0bin001111000100] = 0bin0); +ASSERT (X[0bin001110010101] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001110010101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001110010101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001110010101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001110010101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001110010101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001110010101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001110010101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001110010101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001110010101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001110010101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001110010101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001110010101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001110010101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001110010101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001110010101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001110010101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001110010101] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001110010101] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001110010101] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001110010101] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001110010101] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001110010101] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001110010101] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001110010101] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001110010101] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001110010101] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001110010101] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001110010101] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001110010101] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001110010101] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001110010101] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001110010101] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001110010101] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001110010101] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001110010101] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001110010101] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001110010101] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin001110010101] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001110010101] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin001110010101] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin001110010101] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin001110010101] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin001110010101] & X[0bin011110111000] = 0bin0); +ASSERT (X[0bin001110010101] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin001110010110] & X[0bin001111000101] = 0bin0); +ASSERT (X[0bin001110010110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001110010110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001110010110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001110010110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001110010110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001110010110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001110010110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001110010110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001110010110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001110010110] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001110010110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001110010110] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001110010110] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001110010110] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001110010110] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001110010110] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001110010110] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001110010110] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001110010110] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001110010110] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin001110010110] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin001110010110] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin001110010110] & X[0bin011111100111] = 0bin0); +ASSERT (X[0bin001110101110] & X[0bin001111011101] = 0bin0); +ASSERT (X[0bin001110101110] & X[0bin001111011110] = 0bin0); +ASSERT (X[0bin001110101110] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin001110101110] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin001110101110] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin001110101110] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001110101110] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001110101110] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001110101110] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001110101110] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001110101110] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001110101110] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001110101110] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001110101110] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001110101110] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001110101110] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001110101110] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001110101110] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001110101110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001110101110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001110101110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001110101110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001110101110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001110101111] & X[0bin001111011110] = 0bin0); +ASSERT (X[0bin001110101111] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin001110101111] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin001110101111] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin001110101111] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001110101111] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001110101111] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001110101111] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001110101111] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001110101111] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001110101111] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001110101111] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001110101111] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001110101111] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001110101111] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001110101111] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001110101111] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001110101111] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001110101111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001110101111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001110101111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001110101111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001110101111] & X[0bin010000001100] = 0bin0); +ASSERT (X[0bin001110101111] & X[0bin010000001101] = 0bin0); +ASSERT (X[0bin001110101111] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin001110101111] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin001110101111] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001110101111] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001110101111] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001110101111] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001110101111] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001110101111] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001110101111] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001110101111] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001110101111] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001110101111] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001110101111] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001110101111] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001110101111] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001110101111] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001110101111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001110101111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001110101111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001110101111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin001111011111] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin010000001101] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin010000111011] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin010000111100] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001110110000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin001111100000] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010000111100] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010001101010] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010001101011] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001110110001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin001111100001] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010001101011] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010010011001] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010010011010] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001110110010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin001111100010] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010010011010] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010011001000] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010011001001] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001110110011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin001111100011] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010011001001] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010011110111] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001110110100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin001111100100] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010100100110] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001110110101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin001111100101] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010101010101] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001110110110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin001111100110] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010110000100] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001110110111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin001111100111] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010110110011] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001110111000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin001111101000] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010111100010] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001110111001] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin001111101001] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin011000010001] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001110111010] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin001111101010] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin011001000000] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001110111011] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin001111101011] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin011001101111] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001110111100] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin001111101100] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin011010011110] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001110111101] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin001111101101] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin011011001101] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001110111110] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin001111101110] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin011011111100] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001110111111] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin001111101111] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin011100101011] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin001111000000] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin001111110000] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin011101011010] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin001111000001] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin001111110001] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin011110001001] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin001111000010] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin001111000011] & X[0bin001111110010] = 0bin0); +ASSERT (X[0bin001111000011] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001111000011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001111000011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001111000011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001111000011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001111000011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001111000011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001111000011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001111000011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001111000011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001111000011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001111000011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001111000011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001111000011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001111000011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001111000011] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001111000011] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001111000011] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001111000011] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001111000011] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001111000011] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001111000011] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001111000011] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001111000011] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001111000011] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001111000011] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001111000011] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001111000011] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001111000011] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001111000011] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001111000011] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001111000011] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001111000011] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001111000011] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001111000011] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001111000011] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin001111000011] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001111000011] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin001111000011] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin001111000011] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin001111000011] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin001111000011] & X[0bin011110111000] = 0bin0); +ASSERT (X[0bin001111000011] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin001111000100] & X[0bin001111110011] = 0bin0); +ASSERT (X[0bin001111000100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001111000100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001111000100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001111000100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001111000100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001111000100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001111000100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001111000100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001111000100] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001111000100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001111000100] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001111000100] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001111000100] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001111000100] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001111000100] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001111000100] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001111000100] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001111000100] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001111000100] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin001111000100] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin001111000100] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin001111000100] & X[0bin011111100111] = 0bin0); +ASSERT (X[0bin001111011101] & X[0bin010000001100] = 0bin0); +ASSERT (X[0bin001111011101] & X[0bin010000001101] = 0bin0); +ASSERT (X[0bin001111011101] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin001111011101] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin001111011101] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001111011101] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001111011101] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001111011101] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001111011101] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001111011101] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001111011101] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001111011101] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001111011101] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001111011101] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001111011101] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001111011101] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001111011101] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001111011101] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001111011101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001111011101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001111011101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001111011101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001111011110] & X[0bin010000001101] = 0bin0); +ASSERT (X[0bin001111011110] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin001111011110] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin001111011110] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001111011110] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001111011110] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001111011110] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001111011110] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001111011110] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001111011110] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001111011110] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001111011110] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001111011110] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001111011110] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001111011110] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001111011110] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001111011110] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001111011110] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001111011110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001111011110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001111011110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001111011110] & X[0bin010000111011] = 0bin0); +ASSERT (X[0bin001111011110] & X[0bin010000111100] = 0bin0); +ASSERT (X[0bin001111011110] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin001111011110] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin001111011110] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001111011110] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001111011110] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001111011110] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001111011110] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001111011110] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001111011110] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001111011110] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001111011110] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001111011110] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001111011110] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001111011110] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001111011110] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001111011110] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001111011110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001111011110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001111011110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010000001110] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010000111100] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010001101010] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010001101011] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001111011111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010000001111] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010001101011] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010010011001] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010010011010] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001111100000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010000010000] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010010011010] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010011001000] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010011001001] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001111100001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010000010001] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010011001001] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010011110111] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001111100010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010000010010] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010100100110] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001111100011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010000010011] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010101010101] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001111100100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010000010100] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010110000100] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001111100101] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010000010101] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010110110011] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001111100110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010000010110] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010111100010] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001111100111] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010000010111] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin011000010001] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001111101000] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010000011000] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin011001000000] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001111101001] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010000011001] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin011001101111] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001111101010] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010000011010] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin011010011110] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001111101011] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010000011011] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin011011001101] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001111101100] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010000011100] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin011011111100] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001111101101] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010000011101] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin011100101011] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin001111101110] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin010000011110] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin011101011010] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin001111101111] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin010000011111] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin011110001001] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin001111110000] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin001111110001] & X[0bin010000100000] = 0bin0); +ASSERT (X[0bin001111110001] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001111110001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin001111110001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001111110001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin001111110001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001111110001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin001111110001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001111110001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin001111110001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001111110001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin001111110001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001111110001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin001111110001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001111110001] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin001111110001] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001111110001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin001111110001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001111110001] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin001111110001] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001111110001] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin001111110001] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001111110001] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin001111110001] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001111110001] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin001111110001] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001111110001] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin001111110001] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001111110001] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin001111110001] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001111110001] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin001111110001] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001111110001] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin001111110001] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001111110001] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin001111110001] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001111110001] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin001111110001] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin001111110001] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin001111110001] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin001111110001] & X[0bin011110111000] = 0bin0); +ASSERT (X[0bin001111110001] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin001111110010] & X[0bin010000100001] = 0bin0); +ASSERT (X[0bin001111110010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin001111110010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin001111110010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin001111110010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin001111110010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin001111110010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin001111110010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin001111110010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin001111110010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin001111110010] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin001111110010] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin001111110010] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin001111110010] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin001111110010] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin001111110010] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin001111110010] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin001111110010] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin001111110010] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin001111110010] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin001111110010] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin001111110010] & X[0bin011111100111] = 0bin0); +ASSERT (X[0bin010000001100] & X[0bin010000111011] = 0bin0); +ASSERT (X[0bin010000001100] & X[0bin010000111100] = 0bin0); +ASSERT (X[0bin010000001100] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin010000001100] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin010000001100] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin010000001100] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin010000001100] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin010000001100] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin010000001100] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin010000001100] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin010000001100] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin010000001100] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin010000001100] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin010000001100] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin010000001100] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin010000001100] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin010000001100] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin010000001100] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin010000001100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin010000001100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin010000001100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin010000001101] & X[0bin010000111100] = 0bin0); +ASSERT (X[0bin010000001101] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin010000001101] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin010000001101] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin010000001101] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin010000001101] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin010000001101] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin010000001101] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin010000001101] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin010000001101] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin010000001101] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin010000001101] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin010000001101] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin010000001101] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin010000001101] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin010000001101] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin010000001101] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin010000001101] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin010000001101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin010000001101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin010000001101] & X[0bin010001101010] = 0bin0); +ASSERT (X[0bin010000001101] & X[0bin010001101011] = 0bin0); +ASSERT (X[0bin010000001101] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin010000001101] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin010000001101] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin010000001101] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin010000001101] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin010000001101] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin010000001101] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin010000001101] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin010000001101] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin010000001101] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin010000001101] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin010000001101] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin010000001101] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin010000001101] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin010000001101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin010000001101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin010000001101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin010000001101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010000111101] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010001101011] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010010011001] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010010011010] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010000001110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010000111110] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010010011010] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010011001000] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010011001001] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010000001111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010000111111] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010011001001] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010011110111] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010000010000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010001000000] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010100100110] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010000010001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010001000001] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010101010101] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010000010010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010001000010] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010110000100] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010000010011] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010001000011] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010110110011] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010000010100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010001000100] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010111100010] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010000010101] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010001000101] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin011000010001] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010000010110] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010001000110] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin011001000000] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010000010111] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010001000111] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin011001101111] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010000011000] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010001001000] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin011010011110] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010000011001] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010001001001] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin011011001101] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010000011010] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010001001010] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin011011111100] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010000011011] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin010001001011] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin011100101011] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin010000011100] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin010001001100] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin011101011010] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin010000011101] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin010001001101] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin011110001001] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin010000011110] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin010000011111] & X[0bin010001001110] = 0bin0); +ASSERT (X[0bin010000011111] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin010000011111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin010000011111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin010000011111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010000011111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010000011111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010000011111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010000011111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010000011111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010000011111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010000011111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010000011111] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010000011111] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010000011111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010000011111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010000011111] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010000011111] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010000011111] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010000011111] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010000011111] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010000011111] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010000011111] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010000011111] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010000011111] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010000011111] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010000011111] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010000011111] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010000011111] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010000011111] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010000011111] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010000011111] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010000011111] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin010000011111] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010000011111] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin010000011111] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin010000011111] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin010000011111] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin010000011111] & X[0bin011110111000] = 0bin0); +ASSERT (X[0bin010000011111] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin010000100000] & X[0bin010001001111] = 0bin0); +ASSERT (X[0bin010000100000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin010000100000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010000100000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010000100000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010000100000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010000100000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010000100000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010000100000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010000100000] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010000100000] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010000100000] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010000100000] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010000100000] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010000100000] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010000100000] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010000100000] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010000100000] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin010000100000] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin010000100000] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin010000100000] & X[0bin011111100111] = 0bin0); +ASSERT (X[0bin010000111011] & X[0bin010001101010] = 0bin0); +ASSERT (X[0bin010000111011] & X[0bin010001101011] = 0bin0); +ASSERT (X[0bin010000111011] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin010000111011] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin010000111011] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin010000111011] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin010000111011] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin010000111011] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin010000111011] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin010000111011] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin010000111011] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin010000111011] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin010000111011] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin010000111011] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin010000111011] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin010000111011] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin010000111011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin010000111011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin010000111011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin010000111011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin010000111100] & X[0bin010001101011] = 0bin0); +ASSERT (X[0bin010000111100] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin010000111100] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin010000111100] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin010000111100] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin010000111100] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin010000111100] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin010000111100] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin010000111100] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin010000111100] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin010000111100] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin010000111100] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin010000111100] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin010000111100] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin010000111100] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin010000111100] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin010000111100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin010000111100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin010000111100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin010000111100] & X[0bin010010011001] = 0bin0); +ASSERT (X[0bin010000111100] & X[0bin010010011010] = 0bin0); +ASSERT (X[0bin010000111100] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin010000111100] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin010000111100] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin010000111100] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin010000111100] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin010000111100] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin010000111100] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin010000111100] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin010000111100] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin010000111100] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin010000111100] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin010000111100] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin010000111100] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin010000111100] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin010000111100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin010000111100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010000111100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010001101100] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010010011010] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010011001000] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010011001001] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010000111101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010001101101] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010011001001] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010011110111] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010000111110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010001101110] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010100100110] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010000111111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010001101111] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010101010101] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010001000000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010001110000] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010110000100] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010001000001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010001110001] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010110110011] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010001000010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010001110010] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010111100010] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010001000011] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010001110011] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin011000010001] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010001000100] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010001110100] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin011001000000] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010001000101] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010001110101] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin011001101111] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010001000110] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010001110110] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin011010011110] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010001000111] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010001110111] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin011011001101] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010001001000] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010001111000] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin011011111100] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010001001001] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin010001111001] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin011100101011] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin010001001010] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin010001111010] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin011101011010] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin010001001011] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin010001111011] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin011110001001] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin010001001100] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin010001001101] & X[0bin010001111100] = 0bin0); +ASSERT (X[0bin010001001101] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin010001001101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010001001101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010001001101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010001001101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010001001101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010001001101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010001001101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010001001101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010001001101] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010001001101] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010001001101] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010001001101] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010001001101] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010001001101] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010001001101] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010001001101] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010001001101] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010001001101] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010001001101] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010001001101] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010001001101] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010001001101] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010001001101] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010001001101] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010001001101] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010001001101] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010001001101] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010001001101] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010001001101] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin010001001101] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010001001101] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin010001001101] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin010001001101] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin010001001101] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin010001001101] & X[0bin011110111000] = 0bin0); +ASSERT (X[0bin010001001101] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin010001001110] & X[0bin010001111101] = 0bin0); +ASSERT (X[0bin010001001110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010001001110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010001001110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010001001110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010001001110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010001001110] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010001001110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010001001110] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010001001110] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010001001110] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010001001110] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010001001110] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010001001110] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010001001110] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010001001110] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010001001110] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin010001001110] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin010001001110] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin010001001110] & X[0bin011111100111] = 0bin0); +ASSERT (X[0bin010001101010] & X[0bin010010011001] = 0bin0); +ASSERT (X[0bin010001101010] & X[0bin010010011010] = 0bin0); +ASSERT (X[0bin010001101010] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin010001101010] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin010001101010] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin010001101010] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin010001101010] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin010001101010] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin010001101010] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin010001101010] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin010001101010] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin010001101010] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin010001101010] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin010001101010] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin010001101010] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin010001101010] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin010001101010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin010001101010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010001101010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010001101011] & X[0bin010010011010] = 0bin0); +ASSERT (X[0bin010001101011] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin010001101011] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin010001101011] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin010001101011] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin010001101011] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin010001101011] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin010001101011] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin010001101011] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin010001101011] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin010001101011] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin010001101011] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin010001101011] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin010001101011] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin010001101011] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin010001101011] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin010001101011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010001101011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010001101011] & X[0bin010011001000] = 0bin0); +ASSERT (X[0bin010001101011] & X[0bin010011001001] = 0bin0); +ASSERT (X[0bin010001101011] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin010001101011] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin010001101011] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin010001101011] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin010001101011] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin010001101011] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin010001101011] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin010001101011] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin010001101011] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin010001101011] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin010001101011] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin010001101011] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010001101011] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010001101011] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010001101011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010001101011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010001101100] & X[0bin010010011011] = 0bin0); +ASSERT (X[0bin010001101100] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin010001101100] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin010001101100] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin010001101100] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin010001101100] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin010001101100] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin010001101100] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin010001101100] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin010001101100] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin010001101100] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin010001101100] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin010001101100] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin010001101100] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin010001101100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin010001101100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010001101100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010001101100] & X[0bin010011001001] = 0bin0); +ASSERT (X[0bin010001101100] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin010001101100] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin010001101100] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin010001101100] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin010001101100] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin010001101100] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin010001101100] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin010001101100] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin010001101100] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin010001101100] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin010001101100] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin010001101100] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010001101100] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010001101100] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010001101100] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010001101100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010001101100] & X[0bin010011110111] = 0bin0); +ASSERT (X[0bin010001101100] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin010001101100] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin010001101100] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin010001101100] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin010001101100] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin010001101100] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin010001101100] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin010001101100] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin010001101100] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin010001101100] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010001101100] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010001101100] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010001101100] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010001101100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010001101100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010001101100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010010011100] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010100100110] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010001101101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010010011101] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010101010101] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010001101110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010010011110] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010110000100] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010001101111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010010011111] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010110110011] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010001110000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010010100000] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010111100010] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010001110001] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010010100001] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin011000010001] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010001110010] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010010100010] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin011001000000] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010001110011] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010010100011] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin011001101111] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010001110100] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010010100100] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin011010011110] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010001110101] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010010100101] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin011011001101] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010001110110] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin010010100110] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin011011111100] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010001110111] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin010010100111] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin011100101011] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin010001111000] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin010010101000] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin011101011010] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin010001111001] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin010001111010] & X[0bin010010101001] = 0bin0); +ASSERT (X[0bin010001111010] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010001111010] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010001111010] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010001111010] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010001111010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010001111010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010001111010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010001111010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010001111010] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010001111010] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010001111010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010001111010] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010001111010] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010001111010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010001111010] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010001111010] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010001111010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010001111010] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010001111010] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010001111010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010001111010] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010001111010] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010001111010] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010001111010] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010001111010] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010001111010] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010001111010] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010001111010] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010001111010] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010001111010] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010001111010] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010001111010] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010001111010] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010001111010] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010001111010] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010001111010] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010001111010] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010001111010] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010001111010] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin010001111010] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010001111010] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010001111010] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin010001111010] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin010001111010] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010001111010] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin010001111010] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin010001111010] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin010001111010] & X[0bin011110001001] = 0bin0); +ASSERT (X[0bin010001111010] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin010001111010] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin010001111011] & X[0bin010010101010] = 0bin0); +ASSERT (X[0bin010001111011] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010001111011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010001111011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010001111011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010001111011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010001111011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010001111011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010001111011] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010001111011] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010001111011] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010001111011] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010001111011] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010001111011] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010001111011] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010001111011] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010001111011] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010001111011] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010001111011] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010001111011] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010001111011] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010001111011] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010001111011] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010001111011] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010001111011] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010001111011] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010001111011] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010001111011] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010001111011] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin010001111011] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010001111011] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin010001111011] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin010001111011] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin010001111011] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin010001111011] & X[0bin011110111000] = 0bin0); +ASSERT (X[0bin010001111011] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin010001111100] & X[0bin010010101011] = 0bin0); +ASSERT (X[0bin010001111100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010001111100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010001111100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010001111100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010001111100] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010001111100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010001111100] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010001111100] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010001111100] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010001111100] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010001111100] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010001111100] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010001111100] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010001111100] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010001111100] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin010001111100] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin010001111100] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin010001111100] & X[0bin011111100111] = 0bin0); +ASSERT (X[0bin010010011001] & X[0bin010011001000] = 0bin0); +ASSERT (X[0bin010010011001] & X[0bin010011001001] = 0bin0); +ASSERT (X[0bin010010011001] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin010010011001] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin010010011001] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin010010011001] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin010010011001] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin010010011001] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin010010011001] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin010010011001] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin010010011001] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin010010011001] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin010010011001] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin010010011001] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010010011001] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010010011001] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010010011001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010010011001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010010011010] & X[0bin010011001001] = 0bin0); +ASSERT (X[0bin010010011010] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin010010011010] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin010010011010] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin010010011010] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin010010011010] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin010010011010] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin010010011010] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin010010011010] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin010010011010] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin010010011010] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin010010011010] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin010010011010] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010010011010] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010010011010] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010010011010] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010010011010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010010011010] & X[0bin010011110111] = 0bin0); +ASSERT (X[0bin010010011010] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin010010011010] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin010010011010] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin010010011010] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin010010011010] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin010010011010] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin010010011010] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin010010011010] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin010010011010] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin010010011010] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010010011010] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010010011010] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010010011010] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010010011010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010010011010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010010011010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010010011011] & X[0bin010011001010] = 0bin0); +ASSERT (X[0bin010010011011] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin010010011011] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin010010011011] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin010010011011] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin010010011011] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin010010011011] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin010010011011] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin010010011011] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin010010011011] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin010010011011] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin010010011011] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010010011011] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010010011011] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010010011011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010010011011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010010011011] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin010010011011] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin010010011011] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin010010011011] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin010010011011] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin010010011011] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin010010011011] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin010010011011] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin010010011011] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin010010011011] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010010011011] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010010011011] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010010011011] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010010011011] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010010011011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010010011011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010010011011] & X[0bin010100100110] = 0bin0); +ASSERT (X[0bin010010011011] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin010010011011] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin010010011011] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin010010011011] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin010010011011] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin010010011011] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin010010011011] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin010010011011] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010010011011] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010010011011] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010010011011] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010010011011] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010010011011] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010010011011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010010011011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010011001011] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010101010101] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010010011100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010011001100] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010110000100] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010010011101] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010011001101] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010110110011] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010010011110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010011001110] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010111100010] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010010011111] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010011001111] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin011000010001] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010010100000] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010011010000] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin011001000000] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010010100001] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010011010001] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin011001101111] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010010100010] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010011010010] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin011010011110] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010010100011] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin010011010011] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin011011001101] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010010100100] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin010011010100] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin011011111100] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010010100101] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin010011010101] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin011100101011] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin010010100110] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin010011010110] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin011101011010] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin010010100111] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin010010101000] & X[0bin010011010111] = 0bin0); +ASSERT (X[0bin010010101000] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010010101000] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010010101000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010010101000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010010101000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010010101000] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010010101000] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010010101000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010010101000] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010010101000] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010010101000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010010101000] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010010101000] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010010101000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010010101000] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010010101000] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010010101000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010010101000] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010010101000] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010010101000] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010010101000] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010010101000] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010010101000] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010010101000] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010010101000] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010010101000] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010010101000] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010010101000] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010010101000] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010010101000] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010010101000] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010010101000] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010010101000] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010010101000] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010010101000] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010010101000] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin010010101000] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010010101000] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010010101000] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin010010101000] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin010010101000] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010010101000] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin010010101000] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin010010101000] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin010010101000] & X[0bin011110001001] = 0bin0); +ASSERT (X[0bin010010101000] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin010010101000] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin010010101001] & X[0bin010011011000] = 0bin0); +ASSERT (X[0bin010010101001] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010010101001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010010101001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010010101001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010010101001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010010101001] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010010101001] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010010101001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010010101001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010010101001] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010010101001] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010010101001] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010010101001] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010010101001] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010010101001] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010010101001] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010010101001] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010010101001] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010010101001] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010010101001] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010010101001] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010010101001] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010010101001] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010010101001] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010010101001] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010010101001] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin010010101001] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010010101001] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin010010101001] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin010010101001] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin010010101001] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin010010101001] & X[0bin011110111000] = 0bin0); +ASSERT (X[0bin010010101001] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin010010101010] & X[0bin010011011001] = 0bin0); +ASSERT (X[0bin010010101010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010010101010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010010101010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010010101010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010010101010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010010101010] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010010101010] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010010101010] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010010101010] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010010101010] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010010101010] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010010101010] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010010101010] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010010101010] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin010010101010] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin010010101010] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin010010101010] & X[0bin011111100111] = 0bin0); +ASSERT (X[0bin010011001000] & X[0bin010011110111] = 0bin0); +ASSERT (X[0bin010011001000] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin010011001000] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin010011001000] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin010011001000] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin010011001000] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin010011001000] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin010011001000] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin010011001000] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin010011001000] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin010011001000] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010011001000] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010011001000] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010011001000] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010011001000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010011001000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010011001000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010011001001] & X[0bin010011111000] = 0bin0); +ASSERT (X[0bin010011001001] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin010011001001] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin010011001001] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin010011001001] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin010011001001] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin010011001001] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin010011001001] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin010011001001] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin010011001001] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010011001001] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010011001001] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010011001001] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010011001001] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010011001001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010011001001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010011001001] & X[0bin010100100110] = 0bin0); +ASSERT (X[0bin010011001001] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin010011001001] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin010011001001] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin010011001001] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin010011001001] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin010011001001] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin010011001001] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin010011001001] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010011001001] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010011001001] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010011001001] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010011001001] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010011001001] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010011001001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010011001001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010011001010] & X[0bin010011111001] = 0bin0); +ASSERT (X[0bin010011001010] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin010011001010] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin010011001010] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin010011001010] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin010011001010] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin010011001010] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin010011001010] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin010011001010] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010011001010] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010011001010] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010011001010] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010011001010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010011001010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010011001010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010011001010] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin010011001010] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin010011001010] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin010011001010] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin010011001010] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin010011001010] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin010011001010] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin010011001010] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010011001010] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010011001010] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010011001010] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010011001010] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010011001010] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010011001010] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010011001010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010011001010] & X[0bin010101010101] = 0bin0); +ASSERT (X[0bin010011001010] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin010011001010] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin010011001010] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin010011001010] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin010011001010] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin010011001010] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin010011001010] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010011001010] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010011001010] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010011001010] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010011001010] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010011001010] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010011001010] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010011001010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010011111010] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010110000100] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010011001011] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010011111011] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010110110011] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010011001100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010011111100] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010111100010] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010011001101] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010011111101] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin011000010001] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010011001110] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010011111110] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin011001000000] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010011001111] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010011111111] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin011001101111] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010011010000] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin010100000000] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin011010011110] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010011010001] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin010100000001] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin011011001101] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010011010010] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin010100000010] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin011011111100] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010011010011] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin010100000011] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin011100101011] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin010011010100] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin010100000100] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin011101011010] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin010011010101] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin010011010110] & X[0bin010100000101] = 0bin0); +ASSERT (X[0bin010011010110] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010011010110] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010011010110] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010011010110] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010011010110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010011010110] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010011010110] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010011010110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010011010110] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010011010110] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010011010110] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010011010110] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010011010110] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010011010110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010011010110] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010011010110] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010011010110] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010011010110] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010011010110] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010011010110] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010011010110] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010011010110] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010011010110] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010011010110] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010011010110] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010011010110] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010011010110] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010011010110] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010011010110] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010011010110] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010011010110] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010011010110] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010011010110] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin010011010110] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010011010110] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010011010110] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin010011010110] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin010011010110] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010011010110] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin010011010110] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin010011010110] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin010011010110] & X[0bin011110001001] = 0bin0); +ASSERT (X[0bin010011010110] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin010011010110] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin010011010111] & X[0bin010100000110] = 0bin0); +ASSERT (X[0bin010011010111] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010011010111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010011010111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010011010111] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010011010111] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010011010111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010011010111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010011010111] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010011010111] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010011010111] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010011010111] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010011010111] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010011010111] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010011010111] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010011010111] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010011010111] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010011010111] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010011010111] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010011010111] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010011010111] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010011010111] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010011010111] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010011010111] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010011010111] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin010011010111] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010011010111] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin010011010111] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin010011010111] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin010011010111] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin010011010111] & X[0bin011110111000] = 0bin0); +ASSERT (X[0bin010011010111] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin010011011000] & X[0bin010100000111] = 0bin0); +ASSERT (X[0bin010011011000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010011011000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010011011000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010011011000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010011011000] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010011011000] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010011011000] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010011011000] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010011011000] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010011011000] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010011011000] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010011011000] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010011011000] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin010011011000] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin010011011000] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin010011011000] & X[0bin011111100111] = 0bin0); +ASSERT (X[0bin010011110111] & X[0bin010100100110] = 0bin0); +ASSERT (X[0bin010011110111] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin010011110111] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin010011110111] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin010011110111] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin010011110111] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin010011110111] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin010011110111] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin010011110111] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010011110111] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010011110111] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010011110111] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010011110111] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010011110111] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010011110111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010011110111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010011111000] & X[0bin010100100111] = 0bin0); +ASSERT (X[0bin010011111000] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin010011111000] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin010011111000] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin010011111000] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin010011111000] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin010011111000] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin010011111000] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010011111000] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010011111000] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010011111000] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010011111000] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010011111000] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010011111000] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010011111000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010011111000] & X[0bin010101010101] = 0bin0); +ASSERT (X[0bin010011111000] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin010011111000] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin010011111000] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin010011111000] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin010011111000] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin010011111000] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin010011111000] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010011111000] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010011111000] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010011111000] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010011111000] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010011111000] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010011111000] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010011111000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010011111001] & X[0bin010100101000] = 0bin0); +ASSERT (X[0bin010011111001] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin010011111001] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin010011111001] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin010011111001] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin010011111001] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin010011111001] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010011111001] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010011111001] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010011111001] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010011111001] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010011111001] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010011111001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010011111001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010011111001] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin010011111001] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin010011111001] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin010011111001] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin010011111001] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin010011111001] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin010011111001] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010011111001] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010011111001] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010011111001] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010011111001] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010011111001] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010011111001] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010011111001] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010011111001] & X[0bin010110000100] = 0bin0); +ASSERT (X[0bin010011111001] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin010011111001] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin010011111001] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin010011111001] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin010011111001] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin010011111001] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010011111001] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010011111001] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010011111001] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010011111001] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010011111001] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010011111001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010011111001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010011111010] & X[0bin010100101001] = 0bin0); +ASSERT (X[0bin010011111010] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin010011111010] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin010011111010] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin010011111010] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin010011111010] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010011111010] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010011111010] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010011111010] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010011111010] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010011111010] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010011111010] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010011111010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010011111010] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin010011111010] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin010011111010] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin010011111010] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin010011111010] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin010011111010] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010011111010] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010011111010] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010011111010] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010011111010] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010011111010] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010011111010] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010011111010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010011111010] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin010011111010] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin010011111010] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin010011111010] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin010011111010] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin010011111010] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010011111010] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010011111010] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010011111010] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010011111010] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010011111010] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010011111010] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010011111010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010011111010] & X[0bin010110110011] = 0bin0); +ASSERT (X[0bin010011111010] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin010011111010] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin010011111010] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin010011111010] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin010011111010] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010011111010] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010011111010] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010011111010] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010011111010] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010011111010] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010011111010] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010011111010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010100101010] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010111100010] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010011111011] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010100101011] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin011000010001] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010011111100] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin010100101100] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin011001000000] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010011111101] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin010100101101] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin011001101111] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010011111110] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin010100101110] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin011010011110] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010011111111] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin010100101111] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin011011001101] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010100000000] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin010100110000] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin011011111100] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010100000001] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin010100110001] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin011100101011] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin010100000010] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010100000011] & X[0bin010100110010] = 0bin0); +ASSERT (X[0bin010100000011] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010100000011] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010100000011] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010100000011] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010100000011] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010100000011] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010100000011] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010100000011] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010100000011] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010100000011] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010100000011] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010100000011] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010100000011] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010100000011] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010100000011] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010100000011] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010100000011] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010100000011] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010100000011] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010100000011] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010100000011] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010100000011] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010100000011] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010100000011] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010100000011] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010100000011] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010100000011] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010100000011] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010100000011] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010100000011] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010100000011] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010100000011] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010100000011] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010100000011] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010100000011] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010100000011] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin010100000011] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010100000011] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010100000011] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010100000011] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin010100000011] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin010100000011] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010100000011] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010100000011] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin010100000011] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin010100000011] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin010100000011] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010100000011] & X[0bin011101011010] = 0bin0); +ASSERT (X[0bin010100000011] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin010100000011] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin010100000011] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin010100000100] & X[0bin010100110011] = 0bin0); +ASSERT (X[0bin010100000100] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010100000100] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010100000100] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010100000100] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010100000100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010100000100] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010100000100] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010100000100] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010100000100] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010100000100] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010100000100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010100000100] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010100000100] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010100000100] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010100000100] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010100000100] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010100000100] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010100000100] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010100000100] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010100000100] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010100000100] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010100000100] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010100000100] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010100000100] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010100000100] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010100000100] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010100000100] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010100000100] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010100000100] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010100000100] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin010100000100] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010100000100] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010100000100] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin010100000100] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin010100000100] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010100000100] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin010100000100] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin010100000100] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin010100000100] & X[0bin011110001001] = 0bin0); +ASSERT (X[0bin010100000100] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin010100000100] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin010100000101] & X[0bin010100110100] = 0bin0); +ASSERT (X[0bin010100000101] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010100000101] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010100000101] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010100000101] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010100000101] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010100000101] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010100000101] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010100000101] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010100000101] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010100000101] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010100000101] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010100000101] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010100000101] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010100000101] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010100000101] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010100000101] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010100000101] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010100000101] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010100000101] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010100000101] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010100000101] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010100000101] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin010100000101] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010100000101] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin010100000101] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin010100000101] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin010100000101] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin010100000101] & X[0bin011110111000] = 0bin0); +ASSERT (X[0bin010100000101] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin010100000110] & X[0bin010100110101] = 0bin0); +ASSERT (X[0bin010100000110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010100000110] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010100000110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010100000110] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010100000110] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010100000110] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010100000110] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010100000110] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010100000110] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010100000110] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010100000110] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010100000110] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin010100000110] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin010100000110] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin010100000110] & X[0bin011111100111] = 0bin0); +ASSERT (X[0bin010100100110] & X[0bin010101010101] = 0bin0); +ASSERT (X[0bin010100100110] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin010100100110] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin010100100110] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin010100100110] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin010100100110] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin010100100110] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin010100100110] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010100100110] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010100100110] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010100100110] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010100100110] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010100100110] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010100100110] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010100100110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010100100111] & X[0bin010101010110] = 0bin0); +ASSERT (X[0bin010100100111] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin010100100111] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin010100100111] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin010100100111] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin010100100111] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin010100100111] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010100100111] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010100100111] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010100100111] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010100100111] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010100100111] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010100100111] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010100100111] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010100100111] & X[0bin010110000100] = 0bin0); +ASSERT (X[0bin010100100111] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin010100100111] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin010100100111] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin010100100111] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin010100100111] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin010100100111] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010100100111] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010100100111] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010100100111] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010100100111] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010100100111] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010100100111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010100100111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010100101000] & X[0bin010101010111] = 0bin0); +ASSERT (X[0bin010100101000] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin010100101000] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin010100101000] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin010100101000] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin010100101000] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010100101000] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010100101000] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010100101000] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010100101000] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010100101000] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010100101000] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010100101000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010100101000] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin010100101000] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin010100101000] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin010100101000] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin010100101000] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin010100101000] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010100101000] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010100101000] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010100101000] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010100101000] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010100101000] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010100101000] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010100101000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010100101000] & X[0bin010110110011] = 0bin0); +ASSERT (X[0bin010100101000] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin010100101000] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin010100101000] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin010100101000] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin010100101000] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010100101000] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010100101000] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010100101000] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010100101000] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010100101000] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010100101000] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010100101000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010100101001] & X[0bin010101011000] = 0bin0); +ASSERT (X[0bin010100101001] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin010100101001] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin010100101001] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin010100101001] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010100101001] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010100101001] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010100101001] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010100101001] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010100101001] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010100101001] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010100101001] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010100101001] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin010100101001] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin010100101001] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin010100101001] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin010100101001] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010100101001] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010100101001] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010100101001] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010100101001] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010100101001] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010100101001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010100101001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010100101001] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin010100101001] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin010100101001] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin010100101001] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin010100101001] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010100101001] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010100101001] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010100101001] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010100101001] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010100101001] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010100101001] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010100101001] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010100101001] & X[0bin010111100010] = 0bin0); +ASSERT (X[0bin010100101001] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin010100101001] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin010100101001] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin010100101001] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin010100101001] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010100101001] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010100101001] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010100101001] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010100101001] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010100101001] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010100101001] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin010101011001] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin011000010001] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010100101010] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin010101011010] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin011001000000] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010100101011] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin010101011011] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin011001101111] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010100101100] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin010101011100] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin011010011110] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010100101101] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin010101011101] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin011011001101] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010100101110] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin010101011110] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin011011111100] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010100101111] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin010101011111] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin011100101011] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin010100110000] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010100110001] & X[0bin010101100000] = 0bin0); +ASSERT (X[0bin010100110001] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010100110001] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010100110001] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010100110001] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010100110001] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010100110001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010100110001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010100110001] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010100110001] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010100110001] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010100110001] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010100110001] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010100110001] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010100110001] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010100110001] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010100110001] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010100110001] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010100110001] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010100110001] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010100110001] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010100110001] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010100110001] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010100110001] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010100110001] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010100110001] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010100110001] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010100110001] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010100110001] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010100110001] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010100110001] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010100110001] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010100110001] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin010100110001] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010100110001] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010100110001] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010100110001] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin010100110001] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin010100110001] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010100110001] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010100110001] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin010100110001] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin010100110001] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin010100110001] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010100110001] & X[0bin011101011010] = 0bin0); +ASSERT (X[0bin010100110001] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin010100110001] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin010100110001] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin010100110010] & X[0bin010101100001] = 0bin0); +ASSERT (X[0bin010100110010] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010100110010] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010100110010] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010100110010] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010100110010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010100110010] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010100110010] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010100110010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010100110010] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010100110010] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010100110010] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010100110010] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010100110010] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010100110010] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010100110010] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010100110010] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010100110010] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010100110010] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010100110010] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010100110010] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010100110010] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010100110010] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010100110010] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010100110010] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010100110010] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010100110010] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010100110010] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin010100110010] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010100110010] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010100110010] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin010100110010] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin010100110010] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010100110010] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin010100110010] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin010100110010] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin010100110010] & X[0bin011110001001] = 0bin0); +ASSERT (X[0bin010100110010] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin010100110010] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin010100110011] & X[0bin010101100010] = 0bin0); +ASSERT (X[0bin010100110011] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010100110011] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010100110011] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010100110011] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010100110011] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010100110011] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010100110011] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010100110011] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010100110011] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010100110011] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010100110011] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010100110011] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010100110011] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010100110011] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010100110011] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010100110011] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010100110011] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010100110011] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010100110011] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010100110011] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin010100110011] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010100110011] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin010100110011] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin010100110011] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin010100110011] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin010100110011] & X[0bin011110111000] = 0bin0); +ASSERT (X[0bin010100110011] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin010100110100] & X[0bin010101100011] = 0bin0); +ASSERT (X[0bin010100110100] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010100110100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010100110100] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010100110100] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010100110100] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010100110100] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010100110100] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010100110100] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010100110100] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010100110100] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010100110100] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin010100110100] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin010100110100] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin010100110100] & X[0bin011111100111] = 0bin0); +ASSERT (X[0bin010101010101] & X[0bin010110000100] = 0bin0); +ASSERT (X[0bin010101010101] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin010101010101] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin010101010101] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin010101010101] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin010101010101] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin010101010101] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010101010101] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010101010101] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010101010101] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010101010101] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010101010101] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010101010101] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010101010101] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010101010110] & X[0bin010110000101] = 0bin0); +ASSERT (X[0bin010101010110] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin010101010110] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin010101010110] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin010101010110] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin010101010110] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010101010110] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010101010110] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010101010110] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010101010110] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010101010110] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010101010110] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010101010110] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010101010110] & X[0bin010110110011] = 0bin0); +ASSERT (X[0bin010101010110] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin010101010110] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin010101010110] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin010101010110] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin010101010110] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010101010110] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010101010110] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010101010110] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010101010110] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010101010110] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010101010110] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010101010110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010101010111] & X[0bin010110000110] = 0bin0); +ASSERT (X[0bin010101010111] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin010101010111] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin010101010111] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin010101010111] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010101010111] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010101010111] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010101010111] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010101010111] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010101010111] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010101010111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010101010111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010101010111] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin010101010111] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin010101010111] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin010101010111] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin010101010111] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010101010111] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010101010111] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010101010111] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010101010111] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010101010111] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010101010111] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010101010111] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010101010111] & X[0bin010111100010] = 0bin0); +ASSERT (X[0bin010101010111] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin010101010111] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin010101010111] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin010101010111] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin010101010111] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010101010111] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010101010111] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010101010111] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010101010111] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010101010111] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010101010111] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010101011000] & X[0bin010110000111] = 0bin0); +ASSERT (X[0bin010101011000] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin010101011000] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin010101011000] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010101011000] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010101011000] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010101011000] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010101011000] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010101011000] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010101011000] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010101011000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010101011000] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin010101011000] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin010101011000] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin010101011000] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010101011000] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010101011000] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010101011000] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010101011000] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010101011000] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010101011000] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010101011000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010101011000] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin010101011000] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin010101011000] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin010101011000] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin010101011000] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010101011000] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010101011000] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010101011000] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010101011000] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010101011000] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010101011000] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010101011000] & X[0bin011000010001] = 0bin0); +ASSERT (X[0bin010101011000] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin010101011000] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin010101011000] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin010101011000] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010101011000] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010101011000] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010101011000] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010101011000] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010101011000] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010101011000] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010101011001] & X[0bin010110001000] = 0bin0); +ASSERT (X[0bin010101011001] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin010101011001] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010101011001] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010101011001] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010101011001] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010101011001] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010101011001] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010101011001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010101011001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010101011001] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin010101011001] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin010101011001] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010101011001] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010101011001] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010101011001] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010101011001] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010101011001] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010101011001] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010101011001] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010101011001] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin010101011001] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin010101011001] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin010101011001] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010101011001] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010101011001] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010101011001] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010101011001] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010101011001] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010101011001] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010101011001] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin010101011001] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin010101011001] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin010101011001] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010101011001] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010101011001] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010101011001] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010101011001] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010101011001] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010101011001] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010101011001] & X[0bin011001000000] = 0bin0); +ASSERT (X[0bin010101011001] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin010101011001] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin010101011001] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin010101011001] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010101011001] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010101011001] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010101011001] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010101011001] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010101011001] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin010110001001] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin011001101111] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010101011010] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin010110001010] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin011010011110] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010101011011] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin010110001011] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin011011001101] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010101011100] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin010110001100] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin011011111100] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010101011101] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010101011110] & X[0bin010110001101] = 0bin0); +ASSERT (X[0bin010101011110] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010101011110] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010101011110] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010101011110] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010101011110] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010101011110] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010101011110] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010101011110] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010101011110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010101011110] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010101011110] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010101011110] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010101011110] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010101011110] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010101011110] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010101011110] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010101011110] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010101011110] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010101011110] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010101011110] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010101011110] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010101011110] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010101011110] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010101011110] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010101011110] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010101011110] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010101011110] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010101011110] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010101011110] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010101011110] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin010101011110] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010101011110] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010101011110] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010101011110] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010101011110] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin010101011110] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin010101011110] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010101011110] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010101011110] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010101011110] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin010101011110] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin010101011110] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin010101011110] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010101011110] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010101011110] & X[0bin011100101011] = 0bin0); +ASSERT (X[0bin010101011110] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin010101011110] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin010101011110] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin010101011110] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010101011111] & X[0bin010110001110] = 0bin0); +ASSERT (X[0bin010101011111] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010101011111] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010101011111] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010101011111] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010101011111] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010101011111] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010101011111] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010101011111] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010101011111] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010101011111] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010101011111] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010101011111] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010101011111] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010101011111] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010101011111] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010101011111] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010101011111] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010101011111] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010101011111] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010101011111] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010101011111] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010101011111] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010101011111] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010101011111] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010101011111] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010101011111] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010101011111] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010101011111] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin010101011111] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010101011111] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010101011111] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010101011111] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin010101011111] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin010101011111] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010101011111] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010101011111] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin010101011111] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin010101011111] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin010101011111] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010101011111] & X[0bin011101011010] = 0bin0); +ASSERT (X[0bin010101011111] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin010101011111] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin010101011111] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin010101100000] & X[0bin010110001111] = 0bin0); +ASSERT (X[0bin010101100000] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010101100000] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010101100000] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010101100000] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010101100000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010101100000] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010101100000] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010101100000] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010101100000] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010101100000] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010101100000] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010101100000] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010101100000] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010101100000] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010101100000] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010101100000] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010101100000] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010101100000] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010101100000] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010101100000] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010101100000] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010101100000] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010101100000] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010101100000] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin010101100000] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010101100000] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010101100000] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin010101100000] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin010101100000] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010101100000] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin010101100000] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin010101100000] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin010101100000] & X[0bin011110001001] = 0bin0); +ASSERT (X[0bin010101100000] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin010101100000] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin010101100001] & X[0bin010110010000] = 0bin0); +ASSERT (X[0bin010101100001] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010101100001] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010101100001] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010101100001] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010101100001] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010101100001] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010101100001] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010101100001] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010101100001] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010101100001] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010101100001] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010101100001] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010101100001] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010101100001] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010101100001] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010101100001] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010101100001] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010101100001] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin010101100001] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010101100001] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin010101100001] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin010101100001] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin010101100001] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin010101100001] & X[0bin011110111000] = 0bin0); +ASSERT (X[0bin010101100001] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin010101100010] & X[0bin010110010001] = 0bin0); +ASSERT (X[0bin010101100010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010101100010] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010101100010] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010101100010] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010101100010] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010101100010] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010101100010] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010101100010] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010101100010] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010101100010] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin010101100010] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin010101100010] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin010101100010] & X[0bin011111100111] = 0bin0); +ASSERT (X[0bin010110000100] & X[0bin010110110011] = 0bin0); +ASSERT (X[0bin010110000100] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin010110000100] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin010110000100] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin010110000100] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin010110000100] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010110000100] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010110000100] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010110000100] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010110000100] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010110000100] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010110000100] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010110000100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010110000101] & X[0bin010110110100] = 0bin0); +ASSERT (X[0bin010110000101] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin010110000101] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin010110000101] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin010110000101] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010110000101] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010110000101] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010110000101] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010110000101] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010110000101] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010110000101] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010110000101] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010110000101] & X[0bin010111100010] = 0bin0); +ASSERT (X[0bin010110000101] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin010110000101] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin010110000101] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin010110000101] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin010110000101] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010110000101] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010110000101] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010110000101] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010110000101] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010110000101] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010110000101] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010110000110] & X[0bin010110110101] = 0bin0); +ASSERT (X[0bin010110000110] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin010110000110] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin010110000110] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010110000110] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010110000110] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010110000110] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010110000110] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010110000110] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010110000110] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010110000110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010110000110] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin010110000110] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin010110000110] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin010110000110] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin010110000110] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010110000110] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010110000110] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010110000110] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010110000110] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010110000110] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010110000110] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010110000110] & X[0bin011000010001] = 0bin0); +ASSERT (X[0bin010110000110] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin010110000110] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin010110000110] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin010110000110] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010110000110] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010110000110] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010110000110] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010110000110] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010110000110] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010110000110] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010110000111] & X[0bin010110110110] = 0bin0); +ASSERT (X[0bin010110000111] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin010110000111] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010110000111] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010110000111] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010110000111] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010110000111] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010110000111] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010110000111] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010110000111] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010110000111] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin010110000111] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin010110000111] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin010110000111] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010110000111] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010110000111] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010110000111] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010110000111] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010110000111] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010110000111] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010110000111] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin010110000111] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin010110000111] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin010110000111] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010110000111] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010110000111] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010110000111] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010110000111] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010110000111] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010110000111] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010110000111] & X[0bin011001000000] = 0bin0); +ASSERT (X[0bin010110000111] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin010110000111] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin010110000111] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin010110000111] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010110000111] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010110000111] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010110000111] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010110000111] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010110000111] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010110001000] & X[0bin010110110111] = 0bin0); +ASSERT (X[0bin010110001000] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010110001000] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010110001000] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010110001000] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010110001000] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010110001000] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010110001000] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010110001000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010110001000] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin010110001000] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin010110001000] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010110001000] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010110001000] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010110001000] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010110001000] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010110001000] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010110001000] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010110001000] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin010110001000] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin010110001000] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010110001000] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010110001000] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010110001000] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010110001000] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010110001000] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010110001000] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010110001000] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin010110001000] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin010110001000] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin010110001000] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010110001000] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010110001000] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010110001000] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010110001000] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010110001000] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010110001000] & X[0bin011001101111] = 0bin0); +ASSERT (X[0bin010110001000] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin010110001000] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin010110001000] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin010110001000] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010110001000] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010110001000] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010110001000] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010110001000] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010110001001] & X[0bin010110111000] = 0bin0); +ASSERT (X[0bin010110001001] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010110001001] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010110001001] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010110001001] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010110001001] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010110001001] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010110001001] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010110001001] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin010110001001] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010110001001] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010110001001] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010110001001] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010110001001] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010110001001] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010110001001] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010110001001] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin010110001001] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010110001001] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010110001001] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010110001001] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010110001001] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010110001001] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010110001001] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010110001001] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin010110001001] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin010110001001] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010110001001] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010110001001] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010110001001] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010110001001] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010110001001] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010110001001] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin010110001001] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin010110001001] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin010110001001] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010110001001] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010110001001] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010110001001] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010110001001] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010110001001] & X[0bin011010011110] = 0bin0); +ASSERT (X[0bin010110001001] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin010110001001] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin010110001001] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin010110001001] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010110001001] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010110001001] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010110001001] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010110001010] & X[0bin010110111001] = 0bin0); +ASSERT (X[0bin010110001010] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010110001010] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010110001010] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010110001010] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010110001010] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010110001010] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010110001010] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010110001010] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010110001010] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010110001010] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010110001010] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010110001010] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010110001010] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010110001010] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010110001010] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010110001010] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010110001010] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010110001010] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010110001010] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010110001010] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010110001010] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin010110001010] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010110001010] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010110001010] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010110001010] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010110001010] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010110001010] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010110001010] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin010110001010] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin010110001010] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010110001010] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010110001010] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010110001010] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010110001010] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010110001010] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin010110001010] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin010110001010] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin010110001010] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010110001010] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010110001010] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010110001010] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010110001010] & X[0bin011011001101] = 0bin0); +ASSERT (X[0bin010110001010] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin010110001010] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin010110001010] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin010110001010] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010110001010] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010110001010] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010110001011] & X[0bin010110111010] = 0bin0); +ASSERT (X[0bin010110001011] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010110001011] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010110001011] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010110001011] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010110001011] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010110001011] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010110001011] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010110001011] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010110001011] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010110001011] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010110001011] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010110001011] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010110001011] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010110001011] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010110001011] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010110001011] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010110001011] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010110001011] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010110001011] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010110001011] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010110001011] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010110001011] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010110001011] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010110001011] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin010110001011] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010110001011] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010110001011] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010110001011] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010110001011] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010110001011] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin010110001011] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin010110001011] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010110001011] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010110001011] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010110001011] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010110001011] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin010110001011] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin010110001011] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin010110001011] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010110001011] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010110001011] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010110001011] & X[0bin011011111100] = 0bin0); +ASSERT (X[0bin010110001011] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin010110001011] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin010110001011] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin010110001011] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010110001011] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010110001100] & X[0bin010110111011] = 0bin0); +ASSERT (X[0bin010110001100] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010110001100] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010110001100] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010110001100] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010110001100] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010110001100] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010110001100] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010110001100] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010110001100] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010110001100] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010110001100] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010110001100] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010110001100] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010110001100] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010110001100] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010110001100] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010110001100] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010110001100] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010110001100] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010110001100] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010110001100] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010110001100] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010110001100] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010110001100] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010110001100] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin010110001100] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010110001100] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010110001100] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010110001100] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010110001100] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin010110001100] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin010110001100] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010110001100] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010110001100] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010110001100] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin010110001100] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin010110001100] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin010110001100] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010110001100] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010110001100] & X[0bin011100101011] = 0bin0); +ASSERT (X[0bin010110001100] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin010110001100] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin010110001100] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin010110001100] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010110001101] & X[0bin010110111100] = 0bin0); +ASSERT (X[0bin010110001101] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010110001101] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010110001101] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010110001101] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010110001101] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010110001101] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010110001101] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010110001101] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010110001101] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010110001101] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010110001101] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010110001101] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010110001101] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010110001101] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010110001101] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010110001101] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010110001101] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010110001101] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010110001101] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010110001101] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010110001101] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010110001101] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010110001101] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010110001101] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin010110001101] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010110001101] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010110001101] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010110001101] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin010110001101] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin010110001101] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010110001101] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010110001101] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin010110001101] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin010110001101] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin010110001101] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010110001101] & X[0bin011101011010] = 0bin0); +ASSERT (X[0bin010110001101] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin010110001101] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin010110001101] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin010110001110] & X[0bin010110111101] = 0bin0); +ASSERT (X[0bin010110001110] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010110001110] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010110001110] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010110001110] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010110001110] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010110001110] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010110001110] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010110001110] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010110001110] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010110001110] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010110001110] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010110001110] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010110001110] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010110001110] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010110001110] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010110001110] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010110001110] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010110001110] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010110001110] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010110001110] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010110001110] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin010110001110] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010110001110] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010110001110] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin010110001110] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin010110001110] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010110001110] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin010110001110] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin010110001110] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin010110001110] & X[0bin011110001001] = 0bin0); +ASSERT (X[0bin010110001110] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin010110001110] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin010110001111] & X[0bin010110111110] = 0bin0); +ASSERT (X[0bin010110001111] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010110001111] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010110001111] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010110001111] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010110001111] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010110001111] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010110001111] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010110001111] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010110001111] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010110001111] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010110001111] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010110001111] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010110001111] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010110001111] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010110001111] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010110001111] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin010110001111] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010110001111] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin010110001111] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin010110001111] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin010110001111] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin010110001111] & X[0bin011110111000] = 0bin0); +ASSERT (X[0bin010110001111] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin010110010000] & X[0bin010110111111] = 0bin0); +ASSERT (X[0bin010110010000] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010110010000] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010110010000] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010110010000] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010110010000] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010110010000] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010110010000] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010110010000] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010110010000] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin010110010000] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin010110010000] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin010110010000] & X[0bin011111100111] = 0bin0); +ASSERT (X[0bin010110110011] & X[0bin010111100010] = 0bin0); +ASSERT (X[0bin010110110011] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin010110110011] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin010110110011] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin010110110011] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin010110110011] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010110110011] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010110110011] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010110110011] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010110110011] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010110110011] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010110110011] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010110110100] & X[0bin010111100011] = 0bin0); +ASSERT (X[0bin010110110100] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin010110110100] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin010110110100] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin010110110100] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010110110100] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010110110100] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010110110100] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010110110100] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010110110100] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010110110100] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010110110100] & X[0bin011000010001] = 0bin0); +ASSERT (X[0bin010110110100] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin010110110100] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin010110110100] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin010110110100] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010110110100] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010110110100] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010110110100] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010110110100] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010110110100] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010110110100] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010110110101] & X[0bin010111100100] = 0bin0); +ASSERT (X[0bin010110110101] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin010110110101] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin010110110101] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010110110101] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010110110101] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010110110101] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010110110101] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010110110101] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010110110101] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010110110101] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin010110110101] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin010110110101] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin010110110101] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010110110101] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010110110101] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010110110101] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010110110101] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010110110101] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010110110101] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010110110101] & X[0bin011001000000] = 0bin0); +ASSERT (X[0bin010110110101] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin010110110101] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin010110110101] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin010110110101] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010110110101] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010110110101] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010110110101] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010110110101] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010110110101] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010110110110] & X[0bin010111100101] = 0bin0); +ASSERT (X[0bin010110110110] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin010110110110] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010110110110] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010110110110] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010110110110] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010110110110] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010110110110] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010110110110] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010110110110] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin010110110110] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin010110110110] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010110110110] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010110110110] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010110110110] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010110110110] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010110110110] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010110110110] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010110110110] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin010110110110] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin010110110110] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin010110110110] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010110110110] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010110110110] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010110110110] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010110110110] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010110110110] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010110110110] & X[0bin011001101111] = 0bin0); +ASSERT (X[0bin010110110110] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin010110110110] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin010110110110] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin010110110110] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010110110110] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010110110110] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010110110110] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010110110110] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010110110111] & X[0bin010111100110] = 0bin0); +ASSERT (X[0bin010110110111] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010110110111] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010110110111] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010110110111] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010110110111] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010110110111] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010110110111] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010110110111] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin010110110111] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010110110111] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010110110111] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010110110111] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010110110111] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010110110111] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010110110111] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010110110111] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin010110110111] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin010110110111] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010110110111] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010110110111] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010110110111] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010110110111] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010110110111] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010110110111] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin010110110111] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin010110110111] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin010110110111] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010110110111] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010110110111] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010110110111] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010110110111] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010110110111] & X[0bin011010011110] = 0bin0); +ASSERT (X[0bin010110110111] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin010110110111] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin010110110111] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin010110110111] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010110110111] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010110110111] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010110110111] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010110111000] & X[0bin010111100111] = 0bin0); +ASSERT (X[0bin010110111000] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010110111000] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010110111000] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010110111000] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010110111000] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010110111000] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010110111000] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010110111000] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010110111000] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010110111000] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010110111000] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010110111000] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010110111000] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010110111000] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin010110111000] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010110111000] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010110111000] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010110111000] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010110111000] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010110111000] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010110111000] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin010110111000] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin010110111000] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010110111000] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010110111000] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010110111000] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010110111000] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010110111000] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin010110111000] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin010110111000] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin010110111000] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010110111000] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010110111000] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010110111000] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010110111000] & X[0bin011011001101] = 0bin0); +ASSERT (X[0bin010110111000] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin010110111000] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin010110111000] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin010110111000] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010110111000] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010110111000] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010110111001] & X[0bin010111101000] = 0bin0); +ASSERT (X[0bin010110111001] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010110111001] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010110111001] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010110111001] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010110111001] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010110111001] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010110111001] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010110111001] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010110111001] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010110111001] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010110111001] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010110111001] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010110111001] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010110111001] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010110111001] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010110111001] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010110111001] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010110111001] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin010110111001] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010110111001] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010110111001] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010110111001] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010110111001] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010110111001] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin010110111001] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin010110111001] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010110111001] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010110111001] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010110111001] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010110111001] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin010110111001] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin010110111001] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin010110111001] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010110111001] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010110111001] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010110111001] & X[0bin011011111100] = 0bin0); +ASSERT (X[0bin010110111001] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin010110111001] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin010110111001] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin010110111001] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010110111001] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010110111010] & X[0bin010111101001] = 0bin0); +ASSERT (X[0bin010110111010] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010110111010] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010110111010] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010110111010] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010110111010] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010110111010] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010110111010] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010110111010] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010110111010] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010110111010] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010110111010] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010110111010] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010110111010] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010110111010] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010110111010] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010110111010] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010110111010] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010110111010] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010110111010] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010110111010] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin010110111010] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010110111010] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010110111010] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010110111010] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010110111010] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin010110111010] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin010110111010] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010110111010] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010110111010] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010110111010] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin010110111010] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin010110111010] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin010110111010] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010110111010] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010110111010] & X[0bin011100101011] = 0bin0); +ASSERT (X[0bin010110111010] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin010110111010] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin010110111010] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin010110111010] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010110111011] & X[0bin010111101010] = 0bin0); +ASSERT (X[0bin010110111011] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010110111011] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010110111011] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010110111011] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010110111011] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010110111011] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010110111011] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010110111011] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010110111011] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010110111011] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010110111011] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010110111011] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010110111011] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010110111011] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010110111011] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010110111011] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010110111011] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010110111011] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010110111011] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010110111011] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin010110111011] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010110111011] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010110111011] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010110111011] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin010110111011] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin010110111011] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010110111011] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010110111011] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin010110111011] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin010110111011] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin010110111011] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010110111011] & X[0bin011101011010] = 0bin0); +ASSERT (X[0bin010110111011] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin010110111011] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin010110111011] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin010110111100] & X[0bin010111101011] = 0bin0); +ASSERT (X[0bin010110111100] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010110111100] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010110111100] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010110111100] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010110111100] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010110111100] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010110111100] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010110111100] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010110111100] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010110111100] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010110111100] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010110111100] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010110111100] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010110111100] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010110111100] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010110111100] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010110111100] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010110111100] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin010110111100] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010110111100] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010110111100] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin010110111100] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin010110111100] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010110111100] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin010110111100] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin010110111100] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin010110111100] & X[0bin011110001001] = 0bin0); +ASSERT (X[0bin010110111100] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin010110111100] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin010110111101] & X[0bin010111101100] = 0bin0); +ASSERT (X[0bin010110111101] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010110111101] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010110111101] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010110111101] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010110111101] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010110111101] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010110111101] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010110111101] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010110111101] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010110111101] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010110111101] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010110111101] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010110111101] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010110111101] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin010110111101] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010110111101] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin010110111101] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin010110111101] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin010110111101] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin010110111101] & X[0bin011110111000] = 0bin0); +ASSERT (X[0bin010110111101] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin010110111110] & X[0bin010111101101] = 0bin0); +ASSERT (X[0bin010110111110] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010110111110] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010110111110] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010110111110] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010110111110] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010110111110] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010110111110] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010110111110] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin010110111110] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin010110111110] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin010110111110] & X[0bin011111100111] = 0bin0); +ASSERT (X[0bin010111100010] & X[0bin011000010001] = 0bin0); +ASSERT (X[0bin010111100010] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin010111100010] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin010111100010] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin010111100010] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010111100010] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010111100010] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010111100010] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010111100010] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010111100010] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010111100010] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010111100011] & X[0bin011000010010] = 0bin0); +ASSERT (X[0bin010111100011] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin010111100011] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin010111100011] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010111100011] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010111100011] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010111100011] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010111100011] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010111100011] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010111100011] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010111100011] & X[0bin011001000000] = 0bin0); +ASSERT (X[0bin010111100011] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin010111100011] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin010111100011] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin010111100011] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010111100011] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010111100011] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010111100011] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010111100011] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010111100011] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010111100100] & X[0bin011000010011] = 0bin0); +ASSERT (X[0bin010111100100] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin010111100100] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010111100100] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010111100100] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010111100100] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010111100100] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010111100100] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010111100100] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010111100100] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin010111100100] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin010111100100] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin010111100100] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010111100100] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010111100100] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010111100100] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010111100100] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010111100100] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010111100100] & X[0bin011001101111] = 0bin0); +ASSERT (X[0bin010111100100] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin010111100100] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin010111100100] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin010111100100] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010111100100] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010111100100] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010111100100] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010111100100] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010111100101] & X[0bin011000010100] = 0bin0); +ASSERT (X[0bin010111100101] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010111100101] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010111100101] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010111100101] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010111100101] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010111100101] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010111100101] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010111100101] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin010111100101] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin010111100101] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010111100101] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010111100101] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010111100101] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010111100101] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010111100101] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010111100101] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin010111100101] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin010111100101] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin010111100101] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010111100101] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010111100101] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010111100101] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010111100101] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010111100101] & X[0bin011010011110] = 0bin0); +ASSERT (X[0bin010111100101] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin010111100101] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin010111100101] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin010111100101] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010111100101] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010111100101] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010111100101] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010111100110] & X[0bin011000010101] = 0bin0); +ASSERT (X[0bin010111100110] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010111100110] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010111100110] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010111100110] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010111100110] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010111100110] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010111100110] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin010111100110] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010111100110] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010111100110] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010111100110] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010111100110] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010111100110] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010111100110] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin010111100110] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin010111100110] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010111100110] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010111100110] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010111100110] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010111100110] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010111100110] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin010111100110] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin010111100110] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin010111100110] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010111100110] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010111100110] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010111100110] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010111100110] & X[0bin011011001101] = 0bin0); +ASSERT (X[0bin010111100110] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin010111100110] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin010111100110] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin010111100110] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010111100110] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010111100110] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010111100111] & X[0bin011000010110] = 0bin0); +ASSERT (X[0bin010111100111] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010111100111] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010111100111] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010111100111] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010111100111] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010111100111] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin010111100111] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010111100111] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010111100111] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010111100111] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010111100111] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010111100111] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin010111100111] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010111100111] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010111100111] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010111100111] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010111100111] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010111100111] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin010111100111] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin010111100111] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010111100111] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010111100111] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010111100111] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010111100111] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin010111100111] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin010111100111] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin010111100111] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010111100111] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010111100111] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010111100111] & X[0bin011011111100] = 0bin0); +ASSERT (X[0bin010111100111] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin010111100111] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin010111100111] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin010111100111] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010111100111] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010111101000] & X[0bin011000010111] = 0bin0); +ASSERT (X[0bin010111101000] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010111101000] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010111101000] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010111101000] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010111101000] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin010111101000] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010111101000] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010111101000] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010111101000] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010111101000] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin010111101000] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010111101000] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010111101000] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010111101000] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010111101000] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin010111101000] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010111101000] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010111101000] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010111101000] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010111101000] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin010111101000] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin010111101000] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010111101000] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010111101000] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010111101000] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin010111101000] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin010111101000] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin010111101000] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010111101000] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010111101000] & X[0bin011100101011] = 0bin0); +ASSERT (X[0bin010111101000] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin010111101000] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin010111101000] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin010111101000] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010111101001] & X[0bin011000011000] = 0bin0); +ASSERT (X[0bin010111101001] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010111101001] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010111101001] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010111101001] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin010111101001] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010111101001] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010111101001] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010111101001] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin010111101001] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010111101001] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010111101001] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010111101001] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin010111101001] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010111101001] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010111101001] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010111101001] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin010111101001] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010111101001] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010111101001] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010111101001] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin010111101001] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin010111101001] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010111101001] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010111101001] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin010111101001] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin010111101001] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin010111101001] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010111101001] & X[0bin011101011010] = 0bin0); +ASSERT (X[0bin010111101001] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin010111101001] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin010111101001] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin010111101010] & X[0bin011000011001] = 0bin0); +ASSERT (X[0bin010111101010] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010111101010] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010111101010] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin010111101010] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010111101010] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010111101010] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin010111101010] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010111101010] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010111101010] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin010111101010] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010111101010] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010111101010] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin010111101010] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010111101010] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010111101010] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin010111101010] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010111101010] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010111101010] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin010111101010] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin010111101010] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010111101010] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin010111101010] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin010111101010] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin010111101010] & X[0bin011110001001] = 0bin0); +ASSERT (X[0bin010111101010] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin010111101010] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin010111101011] & X[0bin011000011010] = 0bin0); +ASSERT (X[0bin010111101011] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010111101011] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin010111101011] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010111101011] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin010111101011] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010111101011] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin010111101011] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010111101011] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin010111101011] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010111101011] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin010111101011] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010111101011] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin010111101011] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010111101011] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin010111101011] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin010111101011] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin010111101011] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin010111101011] & X[0bin011110111000] = 0bin0); +ASSERT (X[0bin010111101011] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin010111101100] & X[0bin011000011011] = 0bin0); +ASSERT (X[0bin010111101100] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin010111101100] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin010111101100] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin010111101100] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin010111101100] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin010111101100] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin010111101100] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin010111101100] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin010111101100] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin010111101100] & X[0bin011111100111] = 0bin0); +ASSERT (X[0bin011000010001] & X[0bin011001000000] = 0bin0); +ASSERT (X[0bin011000010001] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin011000010001] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin011000010001] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin011000010001] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin011000010001] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin011000010001] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin011000010001] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin011000010001] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin011000010001] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin011000010010] & X[0bin011001000001] = 0bin0); +ASSERT (X[0bin011000010010] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin011000010010] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin011000010010] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin011000010010] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin011000010010] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin011000010010] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin011000010010] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin011000010010] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin011000010010] & X[0bin011001101111] = 0bin0); +ASSERT (X[0bin011000010010] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin011000010010] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin011000010010] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin011000010010] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin011000010010] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin011000010010] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin011000010010] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin011000010010] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin011000010011] & X[0bin011001000010] = 0bin0); +ASSERT (X[0bin011000010011] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin011000010011] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin011000010011] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin011000010011] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin011000010011] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin011000010011] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin011000010011] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin011000010011] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin011000010011] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin011000010011] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin011000010011] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin011000010011] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin011000010011] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin011000010011] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin011000010011] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin011000010011] & X[0bin011010011110] = 0bin0); +ASSERT (X[0bin011000010011] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin011000010011] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin011000010011] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin011000010011] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin011000010011] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin011000010011] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin011000010011] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin011000010100] & X[0bin011001000011] = 0bin0); +ASSERT (X[0bin011000010100] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin011000010100] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin011000010100] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin011000010100] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin011000010100] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin011000010100] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin011000010100] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin011000010100] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin011000010100] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin011000010100] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin011000010100] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin011000010100] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin011000010100] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin011000010100] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin011000010100] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin011000010100] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin011000010100] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin011000010100] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin011000010100] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin011000010100] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin011000010100] & X[0bin011011001101] = 0bin0); +ASSERT (X[0bin011000010100] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin011000010100] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin011000010100] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin011000010100] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin011000010100] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin011000010100] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin011000010101] & X[0bin011001000100] = 0bin0); +ASSERT (X[0bin011000010101] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin011000010101] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin011000010101] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin011000010101] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin011000010101] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin011000010101] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin011000010101] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin011000010101] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin011000010101] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin011000010101] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin011000010101] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin011000010101] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin011000010101] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin011000010101] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin011000010101] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin011000010101] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin011000010101] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin011000010101] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin011000010101] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin011000010101] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin011000010101] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin011000010101] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin011000010101] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin011000010101] & X[0bin011011111100] = 0bin0); +ASSERT (X[0bin011000010101] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin011000010101] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin011000010101] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin011000010101] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin011000010101] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin011000010110] & X[0bin011001000101] = 0bin0); +ASSERT (X[0bin011000010110] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin011000010110] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin011000010110] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin011000010110] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin011000010110] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin011000010110] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin011000010110] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin011000010110] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin011000010110] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin011000010110] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin011000010110] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin011000010110] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin011000010110] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin011000010110] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin011000010110] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin011000010110] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin011000010110] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin011000010110] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin011000010110] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin011000010110] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin011000010110] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin011000010110] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin011000010110] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin011000010110] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin011000010110] & X[0bin011100101011] = 0bin0); +ASSERT (X[0bin011000010110] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin011000010110] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin011000010110] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin011000010110] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin011000010111] & X[0bin011001000110] = 0bin0); +ASSERT (X[0bin011000010111] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin011000010111] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin011000010111] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin011000010111] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin011000010111] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin011000010111] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin011000010111] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin011000010111] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin011000010111] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin011000010111] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin011000010111] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin011000010111] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin011000010111] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin011000010111] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin011000010111] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin011000010111] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin011000010111] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin011000010111] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin011000010111] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin011000010111] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin011000010111] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin011000010111] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin011000010111] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin011000010111] & X[0bin011101011010] = 0bin0); +ASSERT (X[0bin011000010111] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin011000010111] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin011000010111] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin011000011000] & X[0bin011001000111] = 0bin0); +ASSERT (X[0bin011000011000] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin011000011000] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin011000011000] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin011000011000] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin011000011000] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin011000011000] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin011000011000] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin011000011000] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin011000011000] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin011000011000] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin011000011000] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin011000011000] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin011000011000] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin011000011000] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin011000011000] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin011000011000] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin011000011000] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin011000011000] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin011000011000] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin011000011000] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin011000011000] & X[0bin011110001001] = 0bin0); +ASSERT (X[0bin011000011000] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin011000011000] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin011000011001] & X[0bin011001001000] = 0bin0); +ASSERT (X[0bin011000011001] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin011000011001] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin011000011001] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin011000011001] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin011000011001] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin011000011001] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin011000011001] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin011000011001] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin011000011001] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin011000011001] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin011000011001] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin011000011001] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin011000011001] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin011000011001] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin011000011001] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin011000011001] & X[0bin011110111000] = 0bin0); +ASSERT (X[0bin011000011001] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin011000011010] & X[0bin011001001001] = 0bin0); +ASSERT (X[0bin011000011010] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin011000011010] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin011000011010] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin011000011010] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin011000011010] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin011000011010] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin011000011010] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin011000011010] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin011000011010] & X[0bin011111100111] = 0bin0); +ASSERT (X[0bin011001000000] & X[0bin011001101111] = 0bin0); +ASSERT (X[0bin011001000000] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin011001000000] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin011001000000] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin011001000000] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin011001000000] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin011001000000] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin011001000000] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin011001000000] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin011001000001] & X[0bin011001110000] = 0bin0); +ASSERT (X[0bin011001000001] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin011001000001] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin011001000001] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin011001000001] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin011001000001] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin011001000001] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin011001000001] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin011001000001] & X[0bin011010011110] = 0bin0); +ASSERT (X[0bin011001000001] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin011001000001] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin011001000001] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin011001000001] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin011001000001] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin011001000001] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin011001000001] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin011001000010] & X[0bin011001110001] = 0bin0); +ASSERT (X[0bin011001000010] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin011001000010] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin011001000010] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin011001000010] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin011001000010] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin011001000010] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin011001000010] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin011001000010] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin011001000010] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin011001000010] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin011001000010] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin011001000010] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin011001000010] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin011001000010] & X[0bin011011001101] = 0bin0); +ASSERT (X[0bin011001000010] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin011001000010] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin011001000010] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin011001000010] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin011001000010] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin011001000010] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin011001000011] & X[0bin011001110010] = 0bin0); +ASSERT (X[0bin011001000011] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin011001000011] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin011001000011] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin011001000011] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin011001000011] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin011001000011] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin011001000011] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin011001000011] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin011001000011] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin011001000011] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin011001000011] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin011001000011] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin011001000011] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin011001000011] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin011001000011] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin011001000011] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin011001000011] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin011001000011] & X[0bin011011111100] = 0bin0); +ASSERT (X[0bin011001000011] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin011001000011] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin011001000011] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin011001000011] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin011001000011] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin011001000100] & X[0bin011001110011] = 0bin0); +ASSERT (X[0bin011001000100] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin011001000100] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin011001000100] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin011001000100] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin011001000100] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin011001000100] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin011001000100] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin011001000100] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin011001000100] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin011001000100] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin011001000100] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin011001000100] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin011001000100] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin011001000100] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin011001000100] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin011001000100] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin011001000100] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin011001000100] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin011001000100] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin011001000100] & X[0bin011100101011] = 0bin0); +ASSERT (X[0bin011001000100] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin011001000100] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin011001000100] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin011001000100] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin011001000101] & X[0bin011001110100] = 0bin0); +ASSERT (X[0bin011001000101] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin011001000101] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin011001000101] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin011001000101] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin011001000101] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin011001000101] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin011001000101] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin011001000101] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin011001000101] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin011001000101] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin011001000101] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin011001000101] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin011001000101] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin011001000101] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin011001000101] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin011001000101] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin011001000101] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin011001000101] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin011001000101] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin011001000101] & X[0bin011101011010] = 0bin0); +ASSERT (X[0bin011001000101] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin011001000101] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin011001000101] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin011001000110] & X[0bin011001110101] = 0bin0); +ASSERT (X[0bin011001000110] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin011001000110] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin011001000110] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin011001000110] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin011001000110] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin011001000110] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin011001000110] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin011001000110] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin011001000110] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin011001000110] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin011001000110] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin011001000110] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin011001000110] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin011001000110] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin011001000110] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin011001000110] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin011001000110] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin011001000110] & X[0bin011110001001] = 0bin0); +ASSERT (X[0bin011001000110] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin011001000110] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin011001000111] & X[0bin011001110110] = 0bin0); +ASSERT (X[0bin011001000111] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin011001000111] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin011001000111] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin011001000111] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin011001000111] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin011001000111] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin011001000111] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin011001000111] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin011001000111] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin011001000111] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin011001000111] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin011001000111] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin011001000111] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin011001000111] & X[0bin011110111000] = 0bin0); +ASSERT (X[0bin011001000111] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin011001001000] & X[0bin011001110111] = 0bin0); +ASSERT (X[0bin011001001000] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin011001001000] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin011001001000] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin011001001000] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin011001001000] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin011001001000] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin011001001000] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin011001001000] & X[0bin011111100111] = 0bin0); +ASSERT (X[0bin011001101111] & X[0bin011010011110] = 0bin0); +ASSERT (X[0bin011001101111] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin011001101111] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin011001101111] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin011001101111] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin011001101111] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin011001101111] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin011001101111] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin011001110000] & X[0bin011010011111] = 0bin0); +ASSERT (X[0bin011001110000] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin011001110000] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin011001110000] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin011001110000] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin011001110000] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin011001110000] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin011001110000] & X[0bin011011001101] = 0bin0); +ASSERT (X[0bin011001110000] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin011001110000] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin011001110000] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin011001110000] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin011001110000] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin011001110000] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin011001110001] & X[0bin011010100000] = 0bin0); +ASSERT (X[0bin011001110001] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin011001110001] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin011001110001] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin011001110001] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin011001110001] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin011001110001] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin011001110001] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin011001110001] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin011001110001] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin011001110001] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin011001110001] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin011001110001] & X[0bin011011111100] = 0bin0); +ASSERT (X[0bin011001110001] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin011001110001] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin011001110001] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin011001110001] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin011001110001] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin011001110010] & X[0bin011010100001] = 0bin0); +ASSERT (X[0bin011001110010] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin011001110010] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin011001110010] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin011001110010] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin011001110010] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin011001110010] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin011001110010] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin011001110010] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin011001110010] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin011001110010] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin011001110010] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin011001110010] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin011001110010] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin011001110010] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin011001110010] & X[0bin011100101011] = 0bin0); +ASSERT (X[0bin011001110010] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin011001110010] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin011001110010] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin011001110010] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin011001110011] & X[0bin011010100010] = 0bin0); +ASSERT (X[0bin011001110011] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin011001110011] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin011001110011] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin011001110011] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin011001110011] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin011001110011] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin011001110011] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin011001110011] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin011001110011] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin011001110011] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin011001110011] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin011001110011] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin011001110011] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin011001110011] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin011001110011] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin011001110011] & X[0bin011101011010] = 0bin0); +ASSERT (X[0bin011001110011] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin011001110011] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin011001110011] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin011001110100] & X[0bin011010100011] = 0bin0); +ASSERT (X[0bin011001110100] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin011001110100] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin011001110100] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin011001110100] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin011001110100] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin011001110100] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin011001110100] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin011001110100] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin011001110100] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin011001110100] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin011001110100] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin011001110100] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin011001110100] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin011001110100] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin011001110100] & X[0bin011110001001] = 0bin0); +ASSERT (X[0bin011001110100] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin011001110100] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin011001110101] & X[0bin011010100100] = 0bin0); +ASSERT (X[0bin011001110101] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin011001110101] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin011001110101] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin011001110101] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin011001110101] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin011001110101] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin011001110101] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin011001110101] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin011001110101] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin011001110101] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin011001110101] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin011001110101] & X[0bin011110111000] = 0bin0); +ASSERT (X[0bin011001110101] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin011001110110] & X[0bin011010100101] = 0bin0); +ASSERT (X[0bin011001110110] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin011001110110] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin011001110110] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin011001110110] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin011001110110] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin011001110110] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin011001110110] & X[0bin011111100111] = 0bin0); +ASSERT (X[0bin011010011110] & X[0bin011011001101] = 0bin0); +ASSERT (X[0bin011010011110] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin011010011110] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin011010011110] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin011010011110] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin011010011110] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin011010011110] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin011010011111] & X[0bin011011001110] = 0bin0); +ASSERT (X[0bin011010011111] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin011010011111] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin011010011111] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin011010011111] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin011010011111] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin011010011111] & X[0bin011011111100] = 0bin0); +ASSERT (X[0bin011010011111] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin011010011111] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin011010011111] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin011010011111] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin011010011111] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin011010100000] & X[0bin011011001111] = 0bin0); +ASSERT (X[0bin011010100000] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin011010100000] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin011010100000] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin011010100000] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin011010100000] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin011010100000] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin011010100000] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin011010100000] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin011010100000] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin011010100000] & X[0bin011100101011] = 0bin0); +ASSERT (X[0bin011010100000] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin011010100000] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin011010100000] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin011010100000] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin011010100001] & X[0bin011011010000] = 0bin0); +ASSERT (X[0bin011010100001] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin011010100001] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin011010100001] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin011010100001] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin011010100001] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin011010100001] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin011010100001] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin011010100001] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin011010100001] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin011010100001] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin011010100001] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin011010100001] & X[0bin011101011010] = 0bin0); +ASSERT (X[0bin011010100001] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin011010100001] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin011010100001] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin011010100010] & X[0bin011011010001] = 0bin0); +ASSERT (X[0bin011010100010] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin011010100010] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin011010100010] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin011010100010] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin011010100010] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin011010100010] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin011010100010] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin011010100010] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin011010100010] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin011010100010] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin011010100010] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin011010100010] & X[0bin011110001001] = 0bin0); +ASSERT (X[0bin011010100010] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin011010100010] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin011010100011] & X[0bin011011010010] = 0bin0); +ASSERT (X[0bin011010100011] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin011010100011] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin011010100011] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin011010100011] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin011010100011] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin011010100011] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin011010100011] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin011010100011] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin011010100011] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin011010100011] & X[0bin011110111000] = 0bin0); +ASSERT (X[0bin011010100011] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin011010100100] & X[0bin011011010011] = 0bin0); +ASSERT (X[0bin011010100100] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin011010100100] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin011010100100] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin011010100100] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin011010100100] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin011010100100] & X[0bin011111100111] = 0bin0); +ASSERT (X[0bin011011001101] & X[0bin011011111100] = 0bin0); +ASSERT (X[0bin011011001101] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin011011001101] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin011011001101] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin011011001101] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin011011001101] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin011011001110] & X[0bin011011111101] = 0bin0); +ASSERT (X[0bin011011001110] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin011011001110] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin011011001110] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin011011001110] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin011011001110] & X[0bin011100101011] = 0bin0); +ASSERT (X[0bin011011001110] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin011011001110] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin011011001110] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin011011001110] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin011011001111] & X[0bin011011111110] = 0bin0); +ASSERT (X[0bin011011001111] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin011011001111] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin011011001111] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin011011001111] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin011011001111] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin011011001111] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin011011001111] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin011011001111] & X[0bin011101011010] = 0bin0); +ASSERT (X[0bin011011001111] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin011011001111] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin011011001111] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin011011010000] & X[0bin011011111111] = 0bin0); +ASSERT (X[0bin011011010000] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin011011010000] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin011011010000] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin011011010000] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin011011010000] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin011011010000] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin011011010000] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin011011010000] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin011011010000] & X[0bin011110001001] = 0bin0); +ASSERT (X[0bin011011010000] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin011011010000] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin011011010001] & X[0bin011100000000] = 0bin0); +ASSERT (X[0bin011011010001] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin011011010001] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin011011010001] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin011011010001] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin011011010001] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin011011010001] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin011011010001] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin011011010001] & X[0bin011110111000] = 0bin0); +ASSERT (X[0bin011011010001] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin011011010010] & X[0bin011100000001] = 0bin0); +ASSERT (X[0bin011011010010] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin011011010010] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin011011010010] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin011011010010] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin011011010010] & X[0bin011111100111] = 0bin0); +ASSERT (X[0bin011011111100] & X[0bin011100101011] = 0bin0); +ASSERT (X[0bin011011111100] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin011011111100] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin011011111100] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin011011111100] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin011011111101] & X[0bin011100101100] = 0bin0); +ASSERT (X[0bin011011111101] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin011011111101] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin011011111101] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin011011111101] & X[0bin011101011010] = 0bin0); +ASSERT (X[0bin011011111101] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin011011111101] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin011011111101] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin011011111110] & X[0bin011100101101] = 0bin0); +ASSERT (X[0bin011011111110] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin011011111110] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin011011111110] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin011011111110] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin011011111110] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin011011111110] & X[0bin011110001001] = 0bin0); +ASSERT (X[0bin011011111110] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin011011111110] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin011011111111] & X[0bin011100101110] = 0bin0); +ASSERT (X[0bin011011111111] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin011011111111] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin011011111111] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin011011111111] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin011011111111] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin011011111111] & X[0bin011110111000] = 0bin0); +ASSERT (X[0bin011011111111] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin011100000000] & X[0bin011100101111] = 0bin0); +ASSERT (X[0bin011100000000] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin011100000000] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin011100000000] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin011100000000] & X[0bin011111100111] = 0bin0); +ASSERT (X[0bin011100101011] & X[0bin011101011010] = 0bin0); +ASSERT (X[0bin011100101011] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin011100101011] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin011100101011] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin011100101100] & X[0bin011101011011] = 0bin0); +ASSERT (X[0bin011100101100] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin011100101100] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin011100101100] & X[0bin011110001001] = 0bin0); +ASSERT (X[0bin011100101100] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin011100101100] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin011100101101] & X[0bin011101011100] = 0bin0); +ASSERT (X[0bin011100101101] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin011100101101] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin011100101101] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin011100101101] & X[0bin011110111000] = 0bin0); +ASSERT (X[0bin011100101101] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin011100101110] & X[0bin011101011101] = 0bin0); +ASSERT (X[0bin011100101110] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin011100101110] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin011100101110] & X[0bin011111100111] = 0bin0); +ASSERT (X[0bin011101011010] & X[0bin011110001001] = 0bin0); +ASSERT (X[0bin011101011010] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin011101011010] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin011101011011] & X[0bin011110001010] = 0bin0); +ASSERT (X[0bin011101011011] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin011101011011] & X[0bin011110111000] = 0bin0); +ASSERT (X[0bin011101011011] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin011101011100] & X[0bin011110001011] = 0bin0); +ASSERT (X[0bin011101011100] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin011101011100] & X[0bin011111100111] = 0bin0); +ASSERT (X[0bin011110001001] & X[0bin011110111000] = 0bin0); +ASSERT (X[0bin011110001001] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin011110001010] & X[0bin011110111001] = 0bin0); +ASSERT (X[0bin011110001010] & X[0bin011111100111] = 0bin0); +ASSERT (X[0bin011110111000] & X[0bin011111100111] = 0bin0); +%%%%%%%%%% (6) %%%%%%%%%% +ASSERT (Y[0bin000000000010] & Y[0bin000000110001] = 0bin0); +ASSERT (Y[0bin000000000010] & Y[0bin000000110010] = 0bin0); +ASSERT (Y[0bin000000000010] & Y[0bin000000110011] = 0bin0); +ASSERT (Y[0bin000000000010] & Y[0bin000000110100] = 0bin0); +ASSERT (Y[0bin000000000010] & Y[0bin000000110101] = 0bin0); +ASSERT (Y[0bin000000000010] & Y[0bin000000110110] = 0bin0); +ASSERT (Y[0bin000000000010] & Y[0bin000000110111] = 0bin0); +ASSERT (Y[0bin000000000010] & Y[0bin000000111000] = 0bin0); +ASSERT (Y[0bin000000000010] & Y[0bin000000111001] = 0bin0); +ASSERT (Y[0bin000000000010] & Y[0bin000000111010] = 0bin0); +ASSERT (Y[0bin000000000010] & Y[0bin000000111011] = 0bin0); +ASSERT (Y[0bin000000000010] & Y[0bin000000111100] = 0bin0); +ASSERT (Y[0bin000000000010] & Y[0bin000000111101] = 0bin0); +ASSERT (Y[0bin000000000010] & Y[0bin000000111110] = 0bin0); +ASSERT (Y[0bin000000000010] & Y[0bin000000111111] = 0bin0); +ASSERT (Y[0bin000000000010] & Y[0bin000001000000] = 0bin0); +ASSERT (Y[0bin000000000010] & Y[0bin000001000001] = 0bin0); +ASSERT (Y[0bin000000000010] & Y[0bin000001000010] = 0bin0); +ASSERT (Y[0bin000000000010] & Y[0bin000001000011] = 0bin0); +ASSERT (Y[0bin000000000010] & Y[0bin000001000100] = 0bin0); +ASSERT (Y[0bin000000000010] & Y[0bin000001000101] = 0bin0); +ASSERT (Y[0bin000000000010] & Y[0bin000001000110] = 0bin0); +ASSERT (Y[0bin000000000010] & Y[0bin000001000111] = 0bin0); +ASSERT (Y[0bin000000000010] & Y[0bin000001001000] = 0bin0); +ASSERT (Y[0bin000000000010] & Y[0bin000001001001] = 0bin0); +ASSERT (Y[0bin000000000010] & Y[0bin000001001010] = 0bin0); +ASSERT (Y[0bin000000000010] & Y[0bin000001001011] = 0bin0); +ASSERT (Y[0bin000000000010] & Y[0bin000001001100] = 0bin0); +ASSERT (Y[0bin000000000010] & Y[0bin000001001101] = 0bin0); +ASSERT (Y[0bin000000000010] & Y[0bin000001001110] = 0bin0); +ASSERT (Y[0bin000000000010] & Y[0bin000001001111] = 0bin0); +ASSERT (Y[0bin000000000010] & Y[0bin000001010000] = 0bin0); +ASSERT (Y[0bin000000000010] & Y[0bin000001010001] = 0bin0); +ASSERT (Y[0bin000000000010] & Y[0bin000001010010] = 0bin0); +ASSERT (Y[0bin000000000010] & Y[0bin000001010011] = 0bin0); +ASSERT (Y[0bin000000000010] & Y[0bin000001010100] = 0bin0); +ASSERT (Y[0bin000000000010] & Y[0bin000001010101] = 0bin0); +ASSERT (Y[0bin000000000010] & Y[0bin000001010110] = 0bin0); +ASSERT (Y[0bin000000000010] & Y[0bin000001010111] = 0bin0); +ASSERT (Y[0bin000000000010] & Y[0bin000001011000] = 0bin0); +ASSERT (Y[0bin000000000010] & Y[0bin000001011001] = 0bin0); +ASSERT (Y[0bin000000000010] & Y[0bin000001011010] = 0bin0); +ASSERT (Y[0bin000000000010] & Y[0bin000001011011] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000000110010] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000000110011] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000000110100] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000000110101] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000000110110] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000000110111] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000000111000] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000000111001] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000000111010] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000000111011] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000000111100] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000000111101] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000000111110] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000000111111] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001000000] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001000001] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001000010] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001000011] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001000100] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001000101] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001000110] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001000111] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001001000] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001001001] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001001010] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001001011] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001001100] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001001101] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001001110] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001001111] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001010000] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001010001] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001010010] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001010011] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001010100] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001010101] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001010110] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001010111] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001011000] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001011001] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001011010] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001011011] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001100000] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001100001] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001100010] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001100011] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001100100] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001100101] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001100110] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001100111] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001101000] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001101001] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001101010] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001101011] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001101100] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001101101] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001101110] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001101111] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001110000] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001110001] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001110010] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001110011] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001110100] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001110101] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001110110] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001110111] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001111000] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001111001] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000000011] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000000110011] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000000110100] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000000110101] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000000110110] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000000110111] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000000111000] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000000111001] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000000111010] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000000111011] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000000111100] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000000111101] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000000111110] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000000111111] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001000000] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001000001] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001000010] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001000011] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001000100] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001000101] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001000110] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001000111] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001001000] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001001001] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001001010] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001001011] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001001100] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001001101] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001001110] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001001111] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001010000] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001010001] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001010010] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001010011] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001010100] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001010101] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001010110] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001010111] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001011000] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001011001] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001011010] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001011011] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001100001] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001100010] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001100011] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001100100] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001100101] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001100110] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001100111] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001101000] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001101001] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001101010] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001101011] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001101100] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001101101] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001101110] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001101111] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001110000] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001110001] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001110010] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001110011] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001110100] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001110101] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001110110] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001110111] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001111000] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001111001] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000010001111] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000010010000] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000010010001] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000010010010] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000010010011] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000010010100] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000010010101] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000010010110] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000010010111] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000010011000] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000010011001] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000010011010] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000010011011] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000010011100] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000010011101] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000010011110] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000010011111] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000000100] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000000110100] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000000110101] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000000110110] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000000110111] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000000111000] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000000111001] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000000111010] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000000111011] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000000111100] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000000111101] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000000111110] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000000111111] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001000000] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001000001] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001000010] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001000011] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001000100] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001000101] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001000110] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001000111] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001001000] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001001001] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001001010] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001001011] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001001100] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001001101] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001001110] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001001111] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001010000] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001010001] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001010010] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001010011] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001010100] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001010101] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001010110] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001010111] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001011000] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001011001] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001011010] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001011011] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001100010] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001100011] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001100100] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001100101] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001100110] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001100111] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001101000] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001101001] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001101010] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001101011] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001101100] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001101101] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001101110] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001101111] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001110000] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001110001] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001110010] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001110011] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001110100] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001110101] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001110110] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001110111] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001111000] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001111001] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000010010000] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000010010001] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000010010010] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000010010011] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000010010100] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000010010101] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000010010110] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000010010111] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000010011000] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000010011001] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000010011010] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000010011011] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000010011100] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000010011101] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000010011110] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000010011111] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000010111110] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000010111111] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000011000000] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000011000001] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000011000010] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000011000011] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000011000100] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000011000101] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000011000110] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000011000111] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000011001000] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000011001001] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000011001010] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000000000101] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000000110101] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000000110110] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000000110111] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000000111000] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000000111001] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000000111010] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000000111011] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000000111100] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000000111101] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000000111110] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000000111111] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001000000] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001000001] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001000010] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001000011] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001000100] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001000101] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001000110] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001000111] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001001000] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001001001] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001001010] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001001011] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001001100] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001001101] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001001110] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001001111] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001010000] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001010001] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001010010] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001010011] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001010100] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001010101] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001010110] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001010111] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001011000] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001011001] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001011010] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001011011] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001100011] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001100100] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001100101] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001100110] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001100111] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001101000] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001101001] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001101010] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001101011] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001101100] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001101101] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001101110] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001101111] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001110000] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001110001] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001110010] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001110011] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001110100] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001110101] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001110110] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001110111] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001111000] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001111001] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000010010001] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000010010010] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000010010011] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000010010100] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000010010101] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000010010110] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000010010111] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000010011000] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000010011001] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000010011010] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000010011011] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000010011100] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000010011101] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000010011110] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000010011111] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000010111111] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011000000] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011000001] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011000010] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011000011] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011000100] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011000101] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011000110] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011000111] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011001000] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011001001] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011001010] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011101101] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011101110] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011101111] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011110000] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011110001] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011110010] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011110011] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011110100] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011110101] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011110110] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000000000110] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000000110110] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000000110111] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000000111000] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000000111001] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000000111010] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000000111011] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000000111100] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000000111101] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000000111110] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000000111111] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001000000] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001000001] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001000010] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001000011] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001000100] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001000101] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001000110] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001000111] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001001000] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001001001] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001001010] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001001011] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001001100] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001001101] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001001110] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001001111] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001010000] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001010001] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001010010] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001010011] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001010100] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001010101] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001010110] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001010111] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001011000] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001011001] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001011010] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001011011] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001100100] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001100101] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001100110] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001100111] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001101000] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001101001] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001101010] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001101011] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001101100] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001101101] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001101110] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001101111] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001110000] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001110001] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001110010] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001110011] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001110100] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001110101] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001110110] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001110111] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001111000] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001111001] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000010010010] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000010010011] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000010010100] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000010010101] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000010010110] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000010010111] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000010011000] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000010011001] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000010011010] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000010011011] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000010011100] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000010011101] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000010011110] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000010011111] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011000000] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011000001] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011000010] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011000011] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011000100] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011000101] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011000110] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011000111] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011001000] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011001001] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011001010] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011101110] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011101111] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011110000] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011110001] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011110010] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011110011] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011110100] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011110101] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011110110] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100011100] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100011101] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100011110] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100011111] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100100000] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100100001] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100100010] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100100011] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000000000111] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000000110111] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000000111000] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000000111001] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000000111010] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000000111011] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000000111100] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000000111101] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000000111110] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000000111111] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001000000] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001000001] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001000010] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001000011] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001000100] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001000101] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001000110] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001000111] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001001000] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001001001] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001001010] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001001011] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001001100] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001001101] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001001110] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001001111] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001010000] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001010001] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001010010] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001010011] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001010100] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001010101] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001010110] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001010111] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001011000] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001011001] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001011010] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001011011] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001100101] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001100110] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001100111] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001101000] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001101001] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001101010] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001101011] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001101100] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001101101] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001101110] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001101111] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001110000] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001110001] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001110010] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001110011] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001110100] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001110101] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001110110] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001110111] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001111000] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001111001] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000010010011] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000010010100] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000010010101] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000010010110] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000010010111] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000010011000] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000010011001] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000010011010] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000010011011] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000010011100] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000010011101] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000010011110] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000010011111] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011000001] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011000010] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011000011] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011000100] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011000101] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011000110] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011000111] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011001000] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011001001] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011001010] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011101111] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011110000] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011110001] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011110010] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011110011] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011110100] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011110101] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011110110] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100011101] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100011110] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100011111] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100100000] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100100001] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100100010] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100100011] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000101001011] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000101001100] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000101001101] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000101001110] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000101001111] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000101010000] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000101010001] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000000001000] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000000111000] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000000111001] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000000111010] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000000111011] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000000111100] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000000111101] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000000111110] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000000111111] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001000000] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001000001] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001000010] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001000011] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001000100] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001000101] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001000110] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001000111] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001001000] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001001001] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001001010] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001001011] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001001100] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001001101] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001001110] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001001111] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001010000] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001010001] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001010010] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001010011] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001010100] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001010101] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001010110] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001010111] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001011000] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001011001] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001011010] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001011011] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001100110] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001100111] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001101000] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001101001] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001101010] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001101011] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001101100] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001101101] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001101110] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001101111] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001110000] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001110001] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001110010] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001110011] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001110100] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001110101] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001110110] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001110111] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001111000] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001111001] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000010010100] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000010010101] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000010010110] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000010010111] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000010011000] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000010011001] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000010011010] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000010011011] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000010011100] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000010011101] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000010011110] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000010011111] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000011000010] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000011000011] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000011000100] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000011000101] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000011000110] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000011000111] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000011001000] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000011001001] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000011001010] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000011110000] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000011110001] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000011110010] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000011110011] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000011110100] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000011110101] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000011110110] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100011110] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100011111] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100100000] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100100001] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100100010] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100100011] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000101001100] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000101001101] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000101001110] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000101001111] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000101010000] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000101010001] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000101111010] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000101111011] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000101111100] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000101111101] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000101111110] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000101111111] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000000001001] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000000111001] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000000111010] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000000111011] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000000111100] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000000111101] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000000111110] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000000111111] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001000000] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001000001] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001000010] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001000011] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001000100] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001000101] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001000110] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001000111] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001001000] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001001001] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001001010] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001001011] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001001100] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001001101] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001001110] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001001111] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001010000] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001010001] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001010010] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001010011] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001010100] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001010101] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001010110] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001010111] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001011000] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001011001] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001011010] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001011011] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001100111] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001101000] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001101001] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001101010] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001101011] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001101100] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001101101] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001101110] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001101111] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001110000] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001110001] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001110010] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001110011] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001110100] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001110101] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001110110] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001110111] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001111000] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001111001] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000010010101] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000010010110] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000010010111] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000010011000] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000010011001] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000010011010] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000010011011] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000010011100] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000010011101] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000010011110] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000010011111] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000011000011] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000011000100] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000011000101] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000011000110] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000011000111] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000011001000] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000011001001] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000011001010] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000011110001] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000011110010] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000011110011] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000011110100] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000011110101] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000011110110] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100011111] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100100000] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100100001] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100100010] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100100011] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000101001101] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000101001110] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000101001111] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000101010000] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000101010001] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000101111011] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000101111100] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000101111101] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000101111110] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000101111111] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110101001] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110101010] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110101011] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110101100] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110101101] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000000001010] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000000111010] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000000111011] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000000111100] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000000111101] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000000111110] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000000111111] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000001000000] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000001000001] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000001000010] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000001000011] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000001000100] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000001000101] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000001000110] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000001000111] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000001001000] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000001001001] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000001001010] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000001001011] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000001001100] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000001001101] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000001001110] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000001001111] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000001010000] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000001010001] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000001010010] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000001010011] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000001010100] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000001010101] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000001010110] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000001010111] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000001011000] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000001011001] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000001011010] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000001011011] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000001101000] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000001101001] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000001101010] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000001101011] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000001101100] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000001101101] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000001101110] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000001101111] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000001110000] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000001110001] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000001110010] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000001110011] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000001110100] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000001110101] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000001110110] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000001110111] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000001111000] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000001111001] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000010010110] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000010010111] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000010011000] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000010011001] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000010011010] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000010011011] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000010011100] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000010011101] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000010011110] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000010011111] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000011000100] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000011000101] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000011000110] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000011000111] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000011001000] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000011001001] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000011001010] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000011110010] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000011110011] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000011110100] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000011110101] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000011110110] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000100100000] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000100100001] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000100100010] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000100100011] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000101001110] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000101001111] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000101010000] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000101010001] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000101111100] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000101111101] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000101111110] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000101111111] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000110101010] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000110101011] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000110101100] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000110101101] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000111011000] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000111011001] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000111011010] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000111011011] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000111011100] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000000001011] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000000111011] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000000111100] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000000111101] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000000111110] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000000111111] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000001000000] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000001000001] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000001000010] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000001000011] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000001000100] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000001000101] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000001000110] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000001000111] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000001001000] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000001001001] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000001001010] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000001001011] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000001001100] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000001001101] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000001001110] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000001001111] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000001010000] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000001010001] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000001010010] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000001010011] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000001010100] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000001010101] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000001010110] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000001010111] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000001011000] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000001011001] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000001011010] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000001011011] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000001101001] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000001101010] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000001101011] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000001101100] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000001101101] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000001101110] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000001101111] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000001110000] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000001110001] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000001110010] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000001110011] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000001110100] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000001110101] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000001110110] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000001110111] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000001111000] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000001111001] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000010010111] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000010011000] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000010011001] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000010011010] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000010011011] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000010011100] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000010011101] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000010011110] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000010011111] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000011000101] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000011000110] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000011000111] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000011001000] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000011001001] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000011001010] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000011110011] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000011110100] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000011110101] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000011110110] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000100100001] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000100100010] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000100100011] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000101001111] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000101010000] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000101010001] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000101111101] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000101111110] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000101111111] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000110101011] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000110101100] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000110101101] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000111011001] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000111011010] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000111011011] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000111011100] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin001000000111] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin001000001000] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin001000001001] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin001000001010] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000000001100] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000000111100] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000000111101] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000000111110] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000000111111] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000001000000] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000001000001] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000001000010] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000001000011] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000001000100] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000001000101] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000001000110] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000001000111] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000001001000] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000001001001] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000001001010] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000001001011] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000001001100] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000001001101] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000001001110] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000001001111] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000001010000] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000001010001] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000001010010] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000001010011] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000001010100] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000001010101] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000001010110] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000001010111] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000001011000] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000001011001] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000001011010] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000001011011] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000001101010] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000001101011] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000001101100] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000001101101] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000001101110] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000001101111] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000001110000] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000001110001] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000001110010] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000001110011] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000001110100] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000001110101] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000001110110] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000001110111] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000001111000] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000001111001] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000010011000] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000010011001] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000010011010] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000010011011] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000010011100] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000010011101] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000010011110] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000010011111] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000011000110] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000011000111] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000011001000] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000011001001] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000011001010] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000011110100] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000011110101] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000011110110] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000100100010] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000100100011] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000101010000] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000101010001] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000101111110] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000101111111] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000110101100] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000110101101] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000111011010] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000111011011] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000111011100] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001000001000] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001000001001] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001000001010] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001000110110] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001000110111] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001000111000] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001000111001] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000000001101] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000000111101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000000111110] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000000111111] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000001000000] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000001000001] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000001000010] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000001000011] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000001000100] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000001000101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000001000110] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000001000111] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000001001000] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000001001001] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000001001010] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000001001011] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000001001100] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000001001101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000001001110] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000001001111] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000001010000] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000001010001] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000001010010] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000001010011] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000001010100] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000001010101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000001010110] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000001010111] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000001011000] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000001011001] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000001011010] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000001011011] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000001101011] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000001101100] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000001101101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000001101110] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000001101111] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000001110000] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000001110001] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000001110010] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000001110011] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000001110100] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000001110101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000001110110] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000001110111] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000001111000] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000001111001] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000010011001] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000010011010] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000010011011] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000010011100] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000010011101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000010011110] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000010011111] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000011000111] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000011001000] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000011001001] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000011001010] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000011110101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000011110110] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000100100011] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000101010001] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000101111111] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000110101101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000111011011] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000111011100] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001000001001] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001000001010] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001000110111] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001000111000] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001000111001] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001001100101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001001100110] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001001100111] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001001101000] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000000001110] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000000111110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000000111111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000001000000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000001000001] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000001000010] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000001000011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000001000100] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000001000101] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000001000110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000001000111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000001001000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000001001001] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000001001010] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000001001011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000001001100] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000001001101] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000001001110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000001001111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000001010000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000001010001] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000001010010] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000001010011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000001010100] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000001010101] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000001010110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000001010111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000001011000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000001011001] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000001011010] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000001011011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000001101100] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000001101101] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000001101110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000001101111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000001110000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000001110001] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000001110010] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000001110011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000001110100] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000001110101] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000001110110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000001110111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000001111000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000001111001] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000010011010] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000010011011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000010011100] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000010011101] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000010011110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000010011111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000011001000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000011001001] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000011001010] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000011110110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000111011100] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001000001010] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001000111000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001000111001] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001001100110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001001100111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001001101000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001010010100] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001010010101] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001010010110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000000001111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000000111111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000001000000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000001000001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000001000010] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000001000011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000001000100] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000001000101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000001000110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000001000111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000001001000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000001001001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000001001010] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000001001011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000001001100] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000001001101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000001001110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000001001111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000001010000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000001010001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000001010010] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000001010011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000001010100] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000001010101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000001010110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000001010111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000001011000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000001011001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000001011010] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000001011011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000001101101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000001101110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000001101111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000001110000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000001110001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000001110010] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000001110011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000001110100] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000001110101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000001110110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000001110111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000001111000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000001111001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000010011011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000010011100] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000010011101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000010011110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000010011111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000011001001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000011001010] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001000111001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001001100111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001001101000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001010010101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001010010110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001011000011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001011000100] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001011000101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000000010000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000001000000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000001000001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000001000010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000001000011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000001000100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000001000101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000001000110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000001000111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000001001000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000001001001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000001001010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000001001011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000001001100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000001001101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000001001110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000001001111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000001010000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000001010001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000001010010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000001010011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000001010100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000001010101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000001010110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000001010111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000001011000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000001011001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000001011010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000001011011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000001101110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000001101111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000001110000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000001110001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000001110010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000001110011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000001110100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000001110101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000001110110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000001110111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000001111000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000001111001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000010011100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000010011101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000010011110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000010011111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000011001010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001001101000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001010010110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001011000100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001011000101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001011110010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001011110011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001011110100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000000010001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000001000001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000001000010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000001000011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000001000100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000001000101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000001000110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000001000111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000001001000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000001001001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000001001010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000001001011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000001001100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000001001101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000001001110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000001001111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000001010000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000001010001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000001010010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000001010011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000001010100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000001010101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000001010110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000001010111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000001011000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000001011001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000001011010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000001011011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000001101111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000001110000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000001110001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000001110010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000001110011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000001110100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000001110101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000001110110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000001110111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000001111000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000001111001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000010011101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000010011110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000010011111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001011000101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001011110011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001011110100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001100100001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001100100010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001100100011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000000010010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000001000010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000001000011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000001000100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000001000101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000001000110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000001000111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000001001000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000001001001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000001001010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000001001011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000001001100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000001001101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000001001110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000001001111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000001010000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000001010001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000001010010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000001010011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000001010100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000001010101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000001010110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000001010111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000001011000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000001011001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000001011010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000001011011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000001110000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000001110001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000001110010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000001110011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000001110100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000001110101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000001110110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000001110111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000001111000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000001111001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000010011110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000010011111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001011110100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001100100010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001100100011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001101010000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001101010001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000000010011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000001000011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000001000100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000001000101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000001000110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000001000111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000001001000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000001001001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000001001010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000001001011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000001001100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000001001101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000001001110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000001001111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000001010000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000001010001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000001010010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000001010011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000001010100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000001010101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000001010110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000001010111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000001011000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000001011001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000001011010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000001011011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000001110001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000001110010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000001110011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000001110100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000001110101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000001110110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000001110111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000001111000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000001111001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000010011111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001100100011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001101010001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001101111111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001110000000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000000010100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000001000100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000001000101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000001000110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000001000111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000001001000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000001001001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000001001010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000001001011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000001001100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000001001101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000001001110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000001001111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000001010000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000001010001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000001010010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000001010011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000001010100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000001010101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000001010110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000001010111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000001011000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000001011001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000001011010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000001011011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000001110010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000001110011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000001110100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000001110101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000001110110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000001110111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000001111000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000001111001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001110000000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001110101110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001110101111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000000010101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000001000101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000001000110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000001000111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000001001000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000001001001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000001001010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000001001011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000001001100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000001001101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000001001110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000001001111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000001010000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000001010001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000001010010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000001010011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000001010100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000001010101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000001010110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000001010111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000001011000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000001011001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000001011010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000001011011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000001110011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000001110100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000001110101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000001110110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000001110111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000001111000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000001111001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001110101111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001111011101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001111011110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000000010110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000001000110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000001000111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000001001000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000001001001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000001001010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000001001011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000001001100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000001001101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000001001110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000001001111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000001010000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000001010001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000001010010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000001010011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000001010100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000001010101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000001010110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000001010111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000001011000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000001011001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000001011010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000001011011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000001110100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000001110101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000001110110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000001110111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000001111000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000001111001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001111011110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin010000001100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin010000001101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000000010111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000001000111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000001001000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000001001001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000001001010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000001001011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000001001100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000001001101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000001001110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000001001111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000001010000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000001010001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000001010010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000001010011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000001010100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000001010101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000001010110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000001010111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000001011000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000001011001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000001011010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000001011011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000001110101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000001110110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000001110111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000001111000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000001111001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin010000001101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin010000111011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin010000111100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000000011000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000001001000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000001001001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000001001010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000001001011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000001001100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000001001101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000001001110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000001001111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000001010000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000001010001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000001010010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000001010011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000001010100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000001010101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000001010110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000001010111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000001011000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000001011001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000001011010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000001011011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000001110110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000001110111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000001111000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000001111001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010000111100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010001101010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010001101011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000000011001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000001001001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000001001010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000001001011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000001001100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000001001101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000001001110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000001001111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000001010000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000001010001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000001010010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000001010011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000001010100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000001010101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000001010110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000001010111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000001011000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000001011001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000001011010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000001011011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000001110111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000001111000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000001111001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010001101011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010010011001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010010011010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000000011010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000001001010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000001001011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000001001100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000001001101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000001001110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000001001111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000001010000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000001010001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000001010010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000001010011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000001010100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000001010101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000001010110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000001010111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000001011000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000001011001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000001011010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000001011011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000001111000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000001111001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010010011010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010011001000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010011001001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000000011011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000001001011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000001001100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000001001101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000001001110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000001001111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000001010000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000001010001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000001010010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000001010011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000001010100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000001010101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000001010110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000001010111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000001011000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000001011001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000001011010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000001011011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000001111001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010011001001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010011110111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000000011100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000001001100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000001001101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000001001110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000001001111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000001010000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000001010001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000001010010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000001010011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000001010100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000001010101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000001010110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000001010111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000001011000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000001011001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000001011010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000001011011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010100100110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000000011101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000001001101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000001001110] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000001001111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000001010000] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000001010001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000001010010] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000001010011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000001010100] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000001010101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000001010110] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000001010111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000001011000] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000001011001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000001011010] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000001011011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010101010101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000000011110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000001001110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000001001111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000001010000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000001010001] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000001010010] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000001010011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000001010100] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000001010101] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000001010110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000001010111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000001011000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000001011001] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000001011010] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000001011011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010110000100] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000000011111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000001001111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000001010000] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000001010001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000001010010] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000001010011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000001010100] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000001010101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000001010110] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000001010111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000001011000] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000001011001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000001011010] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000001011011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010110110011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000000100000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000001010000] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000001010001] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000001010010] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000001010011] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000001010100] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000001010101] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000001010110] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000001010111] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000001011000] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000001011001] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000001011010] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000001011011] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010111100010] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000000100001] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000001010001] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000001010010] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000001010011] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000001010100] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000001010101] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000001010110] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000001010111] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000001011000] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000001011001] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000001011010] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000001011011] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin011000010001] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000000100010] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000001010010] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000001010011] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000001010100] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000001010101] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000001010110] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000001010111] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000001011000] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000001011001] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000001011010] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000001011011] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin011001000000] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000000100011] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000001010011] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000001010100] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000001010101] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000001010110] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000001010111] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000001011000] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000001011001] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000001011010] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000001011011] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin011001101111] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000000100100] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000001010100] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000001010101] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000001010110] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000001010111] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000001011000] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000001011001] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000001011010] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000001011011] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin011010011110] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000000100101] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000001010101] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000001010110] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000001010111] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000001011000] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000001011001] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000001011010] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000001011011] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin011011001101] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000000100110] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000001010110] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000001010111] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000001011000] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000001011001] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000001011010] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000001011011] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin011011111100] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000000100111] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin000001010111] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin000001011000] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin000001011001] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin000001011010] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin000001011011] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin011100101011] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin000000101000] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin000001011000] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin000001011001] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin000001011010] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin000001011011] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin011101011010] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin000000101001] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin000001011001] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin000001011010] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin000001011011] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin011110001001] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin000000101010] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin000001011010] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin000001011011] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin011110111000] = 0bin0); +ASSERT (Y[0bin000000101011] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin000000101100] & Y[0bin000001011011] = 0bin0); +ASSERT (Y[0bin000000101100] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000101100] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000101100] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000101100] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000000101100] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000000101100] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000000101100] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000000101100] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000000101100] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000000101100] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000000101100] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000000101100] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000000101100] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000000101100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000000101100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000000101100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000000101100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000000101100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000000101100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000000101100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000000101100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000000101100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000000101100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000000101100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000000101100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000000101100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000000101100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000000101100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000000101100] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000000101100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000000101100] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000000101100] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000000101100] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000000101100] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000000101100] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000000101100] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000000101100] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000000101100] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000000101100] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin000000101100] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin000000101100] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin000000101100] & Y[0bin011111100111] = 0bin0); +ASSERT (Y[0bin000000110001] & Y[0bin000001100000] = 0bin0); +ASSERT (Y[0bin000000110001] & Y[0bin000001100001] = 0bin0); +ASSERT (Y[0bin000000110001] & Y[0bin000001100010] = 0bin0); +ASSERT (Y[0bin000000110001] & Y[0bin000001100011] = 0bin0); +ASSERT (Y[0bin000000110001] & Y[0bin000001100100] = 0bin0); +ASSERT (Y[0bin000000110001] & Y[0bin000001100101] = 0bin0); +ASSERT (Y[0bin000000110001] & Y[0bin000001100110] = 0bin0); +ASSERT (Y[0bin000000110001] & Y[0bin000001100111] = 0bin0); +ASSERT (Y[0bin000000110001] & Y[0bin000001101000] = 0bin0); +ASSERT (Y[0bin000000110001] & Y[0bin000001101001] = 0bin0); +ASSERT (Y[0bin000000110001] & Y[0bin000001101010] = 0bin0); +ASSERT (Y[0bin000000110001] & Y[0bin000001101011] = 0bin0); +ASSERT (Y[0bin000000110001] & Y[0bin000001101100] = 0bin0); +ASSERT (Y[0bin000000110001] & Y[0bin000001101101] = 0bin0); +ASSERT (Y[0bin000000110001] & Y[0bin000001101110] = 0bin0); +ASSERT (Y[0bin000000110001] & Y[0bin000001101111] = 0bin0); +ASSERT (Y[0bin000000110001] & Y[0bin000001110000] = 0bin0); +ASSERT (Y[0bin000000110001] & Y[0bin000001110001] = 0bin0); +ASSERT (Y[0bin000000110001] & Y[0bin000001110010] = 0bin0); +ASSERT (Y[0bin000000110001] & Y[0bin000001110011] = 0bin0); +ASSERT (Y[0bin000000110001] & Y[0bin000001110100] = 0bin0); +ASSERT (Y[0bin000000110001] & Y[0bin000001110101] = 0bin0); +ASSERT (Y[0bin000000110001] & Y[0bin000001110110] = 0bin0); +ASSERT (Y[0bin000000110001] & Y[0bin000001110111] = 0bin0); +ASSERT (Y[0bin000000110001] & Y[0bin000001111000] = 0bin0); +ASSERT (Y[0bin000000110001] & Y[0bin000001111001] = 0bin0); +ASSERT (Y[0bin000000110001] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000000110001] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000000110001] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000000110001] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000000110001] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000000110001] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000000110001] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000000110001] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000000110001] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000000110001] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000000110001] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000000110001] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000110001] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000110001] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000110001] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000110001] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000001100001] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000001100010] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000001100011] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000001100100] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000001100101] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000001100110] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000001100111] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000001101000] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000001101001] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000001101010] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000001101011] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000001101100] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000001101101] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000001101110] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000001101111] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000001110000] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000001110001] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000001110010] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000001110011] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000001110100] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000001110101] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000001110110] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000001110111] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000001111000] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000001111001] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000010001111] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000010010000] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000010010001] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000010010010] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000010010011] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000010010100] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000010010101] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000010010110] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000010010111] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000010011000] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000010011001] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000010011010] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000010011011] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000010011100] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000010011101] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000010011110] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000010011111] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000110010] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000001100010] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000001100011] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000001100100] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000001100101] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000001100110] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000001100111] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000001101000] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000001101001] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000001101010] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000001101011] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000001101100] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000001101101] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000001101110] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000001101111] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000001110000] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000001110001] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000001110010] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000001110011] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000001110100] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000001110101] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000001110110] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000001110111] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000001111000] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000001111001] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000010010000] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000010010001] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000010010010] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000010010011] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000010010100] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000010010101] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000010010110] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000010010111] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000010011000] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000010011001] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000010011010] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000010011011] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000010011100] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000010011101] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000010011110] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000010011111] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000010111110] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000010111111] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000011000000] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000011000001] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000011000010] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000011000011] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000011000100] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000011000101] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000011000110] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000011000111] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000011001000] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000011001001] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000011001010] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000000110011] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000001100011] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000001100100] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000001100101] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000001100110] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000001100111] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000001101000] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000001101001] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000001101010] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000001101011] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000001101100] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000001101101] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000001101110] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000001101111] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000001110000] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000001110001] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000001110010] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000001110011] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000001110100] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000001110101] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000001110110] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000001110111] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000001111000] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000001111001] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000010010001] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000010010010] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000010010011] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000010010100] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000010010101] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000010010110] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000010010111] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000010011000] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000010011001] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000010011010] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000010011011] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000010011100] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000010011101] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000010011110] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000010011111] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000010111111] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011000000] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011000001] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011000010] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011000011] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011000100] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011000101] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011000110] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011000111] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011001000] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011001001] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011001010] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011101101] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011101110] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011101111] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011110000] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011110001] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011110010] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011110011] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011110100] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011110101] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011110110] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000000110100] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000001100100] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000001100101] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000001100110] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000001100111] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000001101000] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000001101001] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000001101010] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000001101011] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000001101100] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000001101101] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000001101110] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000001101111] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000001110000] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000001110001] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000001110010] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000001110011] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000001110100] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000001110101] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000001110110] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000001110111] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000001111000] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000001111001] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000010010010] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000010010011] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000010010100] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000010010101] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000010010110] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000010010111] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000010011000] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000010011001] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000010011010] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000010011011] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000010011100] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000010011101] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000010011110] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000010011111] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011000000] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011000001] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011000010] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011000011] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011000100] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011000101] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011000110] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011000111] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011001000] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011001001] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011001010] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011101110] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011101111] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011110000] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011110001] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011110010] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011110011] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011110100] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011110101] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011110110] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100011100] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100011101] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100011110] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100011111] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100100000] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100100001] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100100010] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100100011] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000000110101] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000001100101] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000001100110] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000001100111] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000001101000] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000001101001] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000001101010] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000001101011] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000001101100] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000001101101] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000001101110] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000001101111] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000001110000] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000001110001] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000001110010] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000001110011] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000001110100] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000001110101] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000001110110] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000001110111] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000001111000] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000001111001] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000010010011] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000010010100] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000010010101] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000010010110] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000010010111] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000010011000] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000010011001] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000010011010] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000010011011] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000010011100] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000010011101] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000010011110] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000010011111] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011000001] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011000010] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011000011] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011000100] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011000101] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011000110] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011000111] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011001000] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011001001] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011001010] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011101111] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011110000] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011110001] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011110010] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011110011] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011110100] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011110101] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011110110] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100011101] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100011110] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100011111] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100100000] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100100001] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100100010] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100100011] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000101001011] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000101001100] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000101001101] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000101001110] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000101001111] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000101010000] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000101010001] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000000110110] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000001100110] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000001100111] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000001101000] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000001101001] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000001101010] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000001101011] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000001101100] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000001101101] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000001101110] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000001101111] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000001110000] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000001110001] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000001110010] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000001110011] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000001110100] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000001110101] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000001110110] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000001110111] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000001111000] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000001111001] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000010010100] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000010010101] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000010010110] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000010010111] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000010011000] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000010011001] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000010011010] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000010011011] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000010011100] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000010011101] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000010011110] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000010011111] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000011000010] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000011000011] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000011000100] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000011000101] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000011000110] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000011000111] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000011001000] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000011001001] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000011001010] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000011110000] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000011110001] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000011110010] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000011110011] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000011110100] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000011110101] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000011110110] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100011110] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100011111] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100100000] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100100001] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100100010] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100100011] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000101001100] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000101001101] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000101001110] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000101001111] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000101010000] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000101010001] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000101111010] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000101111011] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000101111100] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000101111101] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000101111110] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000101111111] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000000110111] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000001100111] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000001101000] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000001101001] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000001101010] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000001101011] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000001101100] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000001101101] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000001101110] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000001101111] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000001110000] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000001110001] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000001110010] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000001110011] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000001110100] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000001110101] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000001110110] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000001110111] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000001111000] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000001111001] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000010010101] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000010010110] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000010010111] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000010011000] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000010011001] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000010011010] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000010011011] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000010011100] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000010011101] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000010011110] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000010011111] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000011000011] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000011000100] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000011000101] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000011000110] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000011000111] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000011001000] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000011001001] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000011001010] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000011110001] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000011110010] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000011110011] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000011110100] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000011110101] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000011110110] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100011111] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100100000] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100100001] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100100010] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100100011] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000101001101] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000101001110] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000101001111] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000101010000] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000101010001] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000101111011] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000101111100] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000101111101] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000101111110] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000101111111] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110101001] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110101010] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110101011] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110101100] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110101101] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000000111000] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000001101000] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000001101001] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000001101010] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000001101011] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000001101100] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000001101101] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000001101110] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000001101111] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000001110000] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000001110001] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000001110010] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000001110011] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000001110100] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000001110101] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000001110110] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000001110111] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000001111000] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000001111001] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000010010110] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000010010111] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000010011000] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000010011001] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000010011010] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000010011011] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000010011100] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000010011101] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000010011110] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000010011111] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000011000100] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000011000101] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000011000110] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000011000111] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000011001000] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000011001001] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000011001010] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000011110010] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000011110011] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000011110100] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000011110101] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000011110110] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000100100000] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000100100001] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000100100010] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000100100011] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000101001110] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000101001111] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000101010000] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000101010001] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000101111100] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000101111101] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000101111110] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000101111111] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000110101010] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000110101011] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000110101100] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000110101101] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000111011000] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000111011001] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000111011010] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000111011011] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000111011100] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000000111001] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000001101001] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000001101010] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000001101011] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000001101100] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000001101101] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000001101110] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000001101111] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000001110000] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000001110001] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000001110010] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000001110011] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000001110100] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000001110101] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000001110110] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000001110111] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000001111000] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000001111001] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000010010111] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000010011000] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000010011001] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000010011010] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000010011011] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000010011100] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000010011101] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000010011110] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000010011111] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000011000101] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000011000110] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000011000111] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000011001000] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000011001001] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000011001010] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000011110011] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000011110100] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000011110101] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000011110110] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000100100001] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000100100010] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000100100011] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000101001111] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000101010000] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000101010001] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000101111101] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000101111110] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000101111111] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000110101011] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000110101100] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000110101101] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000111011001] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000111011010] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000111011011] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000111011100] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin001000000111] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin001000001000] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin001000001001] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin001000001010] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000000111010] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000001101010] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000001101011] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000001101100] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000001101101] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000001101110] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000001101111] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000001110000] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000001110001] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000001110010] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000001110011] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000001110100] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000001110101] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000001110110] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000001110111] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000001111000] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000001111001] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000010011000] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000010011001] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000010011010] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000010011011] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000010011100] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000010011101] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000010011110] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000010011111] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000011000110] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000011000111] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000011001000] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000011001001] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000011001010] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000011110100] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000011110101] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000011110110] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000100100010] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000100100011] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000101010000] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000101010001] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000101111110] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000101111111] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000110101100] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000110101101] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000111011010] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000111011011] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000111011100] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001000001000] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001000001001] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001000001010] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001000110110] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001000110111] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001000111000] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001000111001] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000000111011] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000001101011] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000001101100] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000001101101] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000001101110] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000001101111] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000001110000] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000001110001] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000001110010] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000001110011] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000001110100] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000001110101] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000001110110] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000001110111] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000001111000] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000001111001] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000010011001] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000010011010] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000010011011] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000010011100] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000010011101] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000010011110] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000010011111] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000011000111] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000011001000] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000011001001] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000011001010] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000011110101] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000011110110] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000100100011] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000101010001] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000101111111] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000110101101] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000111011011] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000111011100] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001000001001] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001000001010] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001000110111] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001000111000] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001000111001] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001001100101] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001001100110] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001001100111] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001001101000] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000000111100] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000001101100] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000001101101] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000001101110] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000001101111] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000001110000] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000001110001] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000001110010] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000001110011] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000001110100] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000001110101] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000001110110] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000001110111] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000001111000] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000001111001] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000010011010] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000010011011] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000010011100] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000010011101] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000010011110] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000010011111] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000011001000] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000011001001] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000011001010] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000011110110] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000111011100] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001000001010] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001000111000] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001000111001] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001001100110] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001001100111] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001001101000] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001010010100] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001010010101] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001010010110] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000000111101] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000001101101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000001101110] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000001101111] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000001110000] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000001110001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000001110010] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000001110011] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000001110100] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000001110101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000001110110] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000001110111] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000001111000] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000001111001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000010011011] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000010011100] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000010011101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000010011110] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000010011111] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000011001001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000011001010] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001000111001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001001100111] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001001101000] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001010010101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001010010110] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001011000011] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001011000100] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001011000101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000000111110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000001101110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000001101111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000001110000] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000001110001] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000001110010] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000001110011] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000001110100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000001110101] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000001110110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000001110111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000001111000] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000001111001] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000010011100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000010011101] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000010011110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000010011111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000011001010] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001001101000] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001010010110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001011000100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001011000101] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001011110010] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001011110011] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001011110100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000000111111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000001101111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000001110000] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000001110001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000001110010] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000001110011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000001110100] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000001110101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000001110110] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000001110111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000001111000] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000001111001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000010011101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000010011110] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000010011111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001011000101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001011110011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001011110100] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001100100001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001100100010] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001100100011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000001000000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000001110000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000001110001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000001110010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000001110011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000001110100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000001110101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000001110110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000001110111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000001111000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000001111001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000010011110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000010011111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001011110100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001100100010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001100100011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001101010000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001101010001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000001000001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000001110001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000001110010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000001110011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000001110100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000001110101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000001110110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000001110111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000001111000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000001111001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000010011111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001100100011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001101010001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001101111111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001110000000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000001000010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000001110010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000001110011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000001110100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000001110101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000001110110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000001110111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000001111000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000001111001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001110000000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001110101110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001110101111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000001000011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000001110011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000001110100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000001110101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000001110110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000001110111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000001111000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000001111001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001110101111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001111011101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001111011110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000001000100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000001110100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000001110101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000001110110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000001110111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000001111000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000001111001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001111011110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin010000001100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin010000001101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000001000101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000001110101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000001110110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000001110111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000001111000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000001111001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin010000001101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin010000111011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin010000111100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000001000110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000001110110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000001110111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000001111000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000001111001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010000111100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010001101010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010001101011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000001000111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000001110111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000001111000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000001111001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010001101011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010010011001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010010011010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000001001000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000001111000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000001111001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010010011010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010011001000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010011001001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000001001001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000001111001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010011001001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010011110111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000001001010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000001111010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010100100110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000001001011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000001111011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010101010101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000001001100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000001111100] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010110000100] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000001001101] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000001111101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010110110011] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000001001110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000001111110] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010111100010] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000001001111] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000001111111] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin011000010001] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000001010000] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000010000000] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin011001000000] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000001010001] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000010000001] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin011001101111] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000001010010] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000010000010] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin011010011110] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000001010011] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000010000011] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin011011001101] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000001010100] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000010000100] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin011011111100] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000001010101] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin000010000101] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin011100101011] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin000001010110] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin000010000110] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin011101011010] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin000001010111] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin000010000111] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin011110001001] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin000001011000] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin000010001000] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin011110111000] = 0bin0); +ASSERT (Y[0bin000001011001] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin000001011010] & Y[0bin000010001001] = 0bin0); +ASSERT (Y[0bin000001011010] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001011010] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001011010] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001011010] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001011010] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001011010] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001011010] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001011010] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000001011010] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000001011010] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000001011010] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000001011010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000001011010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000001011010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000001011010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000001011010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000001011010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000001011010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000001011010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000001011010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000001011010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000001011010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000001011010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000001011010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000001011010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000001011010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000001011010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000001011010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000001011010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000001011010] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000001011010] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000001011010] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000001011010] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000001011010] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000001011010] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000001011010] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000001011010] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000001011010] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin000001011010] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin000001011010] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin000001011010] & Y[0bin011111100111] = 0bin0); +ASSERT (Y[0bin000001100000] & Y[0bin000010001111] = 0bin0); +ASSERT (Y[0bin000001100000] & Y[0bin000010010000] = 0bin0); +ASSERT (Y[0bin000001100000] & Y[0bin000010010001] = 0bin0); +ASSERT (Y[0bin000001100000] & Y[0bin000010010010] = 0bin0); +ASSERT (Y[0bin000001100000] & Y[0bin000010010011] = 0bin0); +ASSERT (Y[0bin000001100000] & Y[0bin000010010100] = 0bin0); +ASSERT (Y[0bin000001100000] & Y[0bin000010010101] = 0bin0); +ASSERT (Y[0bin000001100000] & Y[0bin000010010110] = 0bin0); +ASSERT (Y[0bin000001100000] & Y[0bin000010010111] = 0bin0); +ASSERT (Y[0bin000001100000] & Y[0bin000010011000] = 0bin0); +ASSERT (Y[0bin000001100000] & Y[0bin000010011001] = 0bin0); +ASSERT (Y[0bin000001100000] & Y[0bin000010011010] = 0bin0); +ASSERT (Y[0bin000001100000] & Y[0bin000010011011] = 0bin0); +ASSERT (Y[0bin000001100000] & Y[0bin000010011100] = 0bin0); +ASSERT (Y[0bin000001100000] & Y[0bin000010011101] = 0bin0); +ASSERT (Y[0bin000001100000] & Y[0bin000010011110] = 0bin0); +ASSERT (Y[0bin000001100000] & Y[0bin000010011111] = 0bin0); +ASSERT (Y[0bin000001100000] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000001100000] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000001100000] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000001100000] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000001100000] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000001100000] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000001100000] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000001100000] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000001100000] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000001100000] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000001100000] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000001100000] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000001100000] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000001100000] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000001100000] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000001100000] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000001100000] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000001100000] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001100000] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001100000] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001100000] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001100000] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001100000] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001100000] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000010010000] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000010010001] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000010010010] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000010010011] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000010010100] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000010010101] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000010010110] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000010010111] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000010011000] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000010011001] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000010011010] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000010011011] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000010011100] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000010011101] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000010011110] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000010011111] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000010111110] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000010111111] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000011000000] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000011000001] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000011000010] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000011000011] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000011000100] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000011000101] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000011000110] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000011000111] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000011001000] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000011001001] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000011001010] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001100001] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000010010001] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000010010010] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000010010011] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000010010100] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000010010101] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000010010110] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000010010111] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000010011000] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000010011001] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000010011010] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000010011011] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000010011100] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000010011101] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000010011110] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000010011111] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000010111111] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011000000] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011000001] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011000010] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011000011] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011000100] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011000101] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011000110] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011000111] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011001000] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011001001] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011001010] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011101101] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011101110] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011101111] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011110000] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011110001] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011110010] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011110011] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011110100] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011110101] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011110110] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001100010] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000010010010] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000010010011] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000010010100] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000010010101] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000010010110] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000010010111] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000010011000] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000010011001] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000010011010] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000010011011] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000010011100] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000010011101] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000010011110] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000010011111] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011000000] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011000001] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011000010] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011000011] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011000100] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011000101] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011000110] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011000111] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011001000] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011001001] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011001010] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011101110] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011101111] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011110000] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011110001] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011110010] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011110011] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011110100] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011110101] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011110110] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100011100] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100011101] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100011110] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100011111] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100100000] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100100001] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100100010] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100100011] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001100011] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000010010011] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000010010100] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000010010101] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000010010110] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000010010111] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000010011000] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000010011001] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000010011010] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000010011011] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000010011100] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000010011101] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000010011110] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000010011111] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011000001] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011000010] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011000011] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011000100] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011000101] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011000110] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011000111] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011001000] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011001001] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011001010] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011101111] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011110000] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011110001] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011110010] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011110011] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011110100] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011110101] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011110110] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100011101] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100011110] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100011111] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100100000] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100100001] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100100010] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100100011] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000101001011] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000101001100] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000101001101] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000101001110] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000101001111] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000101010000] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000101010001] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001100100] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000010010100] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000010010101] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000010010110] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000010010111] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000010011000] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000010011001] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000010011010] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000010011011] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000010011100] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000010011101] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000010011110] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000010011111] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000011000010] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000011000011] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000011000100] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000011000101] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000011000110] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000011000111] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000011001000] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000011001001] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000011001010] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000011110000] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000011110001] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000011110010] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000011110011] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000011110100] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000011110101] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000011110110] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100011110] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100011111] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100100000] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100100001] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100100010] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100100011] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000101001100] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000101001101] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000101001110] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000101001111] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000101010000] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000101010001] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000101111010] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000101111011] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000101111100] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000101111101] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000101111110] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000101111111] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001100101] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000010010101] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000010010110] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000010010111] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000010011000] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000010011001] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000010011010] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000010011011] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000010011100] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000010011101] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000010011110] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000010011111] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000011000011] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000011000100] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000011000101] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000011000110] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000011000111] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000011001000] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000011001001] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000011001010] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000011110001] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000011110010] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000011110011] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000011110100] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000011110101] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000011110110] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100011111] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100100000] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100100001] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100100010] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100100011] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000101001101] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000101001110] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000101001111] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000101010000] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000101010001] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000101111011] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000101111100] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000101111101] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000101111110] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000101111111] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110101001] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110101010] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110101011] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110101100] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110101101] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000001100110] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000010010110] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000010010111] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000010011000] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000010011001] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000010011010] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000010011011] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000010011100] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000010011101] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000010011110] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000010011111] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000011000100] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000011000101] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000011000110] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000011000111] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000011001000] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000011001001] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000011001010] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000011110010] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000011110011] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000011110100] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000011110101] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000011110110] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000100100000] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000100100001] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000100100010] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000100100011] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000101001110] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000101001111] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000101010000] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000101010001] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000101111100] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000101111101] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000101111110] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000101111111] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000110101010] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000110101011] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000110101100] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000110101101] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000111011000] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000111011001] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000111011010] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000111011011] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000111011100] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000001100111] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000010010111] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000010011000] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000010011001] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000010011010] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000010011011] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000010011100] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000010011101] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000010011110] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000010011111] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000011000101] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000011000110] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000011000111] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000011001000] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000011001001] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000011001010] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000011110011] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000011110100] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000011110101] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000011110110] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000100100001] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000100100010] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000100100011] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000101001111] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000101010000] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000101010001] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000101111101] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000101111110] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000101111111] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000110101011] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000110101100] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000110101101] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000111011001] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000111011010] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000111011011] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000111011100] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin001000000111] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin001000001000] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin001000001001] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin001000001010] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000001101000] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000010011000] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000010011001] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000010011010] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000010011011] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000010011100] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000010011101] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000010011110] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000010011111] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000011000110] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000011000111] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000011001000] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000011001001] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000011001010] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000011110100] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000011110101] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000011110110] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000100100010] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000100100011] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000101010000] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000101010001] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000101111110] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000101111111] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000110101100] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000110101101] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000111011010] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000111011011] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000111011100] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001000001000] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001000001001] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001000001010] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001000110110] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001000110111] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001000111000] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001000111001] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000001101001] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000010011001] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000010011010] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000010011011] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000010011100] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000010011101] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000010011110] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000010011111] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000011000111] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000011001000] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000011001001] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000011001010] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000011110101] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000011110110] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000100100011] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000101010001] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000101111111] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000110101101] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000111011011] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000111011100] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001000001001] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001000001010] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001000110111] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001000111000] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001000111001] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001001100101] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001001100110] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001001100111] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001001101000] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000001101010] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000010011010] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000010011011] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000010011100] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000010011101] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000010011110] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000010011111] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000011001000] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000011001001] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000011001010] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000011110110] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000111011100] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001000001010] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001000111000] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001000111001] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001001100110] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001001100111] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001001101000] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001010010100] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001010010101] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001010010110] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000001101011] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000010011011] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000010011100] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000010011101] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000010011110] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000010011111] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000011001001] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000011001010] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001000111001] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001001100111] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001001101000] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001010010101] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001010010110] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001011000011] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001011000100] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001011000101] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000001101100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000010011100] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000010011101] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000010011110] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000010011111] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000011001010] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001001101000] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001010010110] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001011000100] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001011000101] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001011110010] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001011110011] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001011110100] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000001101101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000010011101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000010011110] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000010011111] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001011000101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001011110011] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001011110100] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001100100001] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001100100010] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001100100011] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000001101110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000010011110] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000010011111] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001011110100] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001100100010] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001100100011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001101010000] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001101010001] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000001101111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000010011111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001100100011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001101010001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001101111111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001110000000] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000001110000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000010100000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001110000000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001110101110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001110101111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000001110001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000010100001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001110101111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001111011101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001111011110] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000001110010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000010100010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001111011110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin010000001100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin010000001101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000001110011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000010100011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin010000001101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin010000111011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin010000111100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000001110100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000010100100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010000111100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010001101010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010001101011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000001110101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000010100101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010001101011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010010011001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010010011010] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000001110110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000010100110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010010011010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010011001000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010011001001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000001110111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000010100111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010011001001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010011110111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000001111000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000010101000] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010100100110] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000001111001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000010101001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010101010101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000001111010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000010101010] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010110000100] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000001111011] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000010101011] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010110110011] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000001111100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000010101100] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010111100010] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000001111101] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000010101101] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin011000010001] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000001111110] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000010101110] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin011001000000] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000001111111] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000010101111] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin011001101111] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000010000000] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000010110000] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin011010011110] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000010000001] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000010110001] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin011011001101] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000010000010] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin000010110010] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin011011111100] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000010000011] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin000010110011] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin011100101011] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin000010000100] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin000010110100] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin011101011010] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin000010000101] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin000010110101] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin011110001001] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin000010000110] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin000010110110] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin011110111000] = 0bin0); +ASSERT (Y[0bin000010000111] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin000010001000] & Y[0bin000010110111] = 0bin0); +ASSERT (Y[0bin000010001000] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000010001000] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000010001000] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000010001000] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000010001000] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000010001000] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000010001000] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000010001000] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000010001000] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000010001000] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000010001000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000010001000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000010001000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000010001000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000010001000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000010001000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000010001000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000010001000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000010001000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000010001000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000010001000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000010001000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000010001000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000010001000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000010001000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000010001000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000010001000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000010001000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000010001000] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000010001000] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000010001000] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000010001000] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000010001000] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000010001000] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000010001000] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000010001000] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000010001000] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin000010001000] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin000010001000] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin000010001000] & Y[0bin011111100111] = 0bin0); +ASSERT (Y[0bin000010001111] & Y[0bin000010111110] = 0bin0); +ASSERT (Y[0bin000010001111] & Y[0bin000010111111] = 0bin0); +ASSERT (Y[0bin000010001111] & Y[0bin000011000000] = 0bin0); +ASSERT (Y[0bin000010001111] & Y[0bin000011000001] = 0bin0); +ASSERT (Y[0bin000010001111] & Y[0bin000011000010] = 0bin0); +ASSERT (Y[0bin000010001111] & Y[0bin000011000011] = 0bin0); +ASSERT (Y[0bin000010001111] & Y[0bin000011000100] = 0bin0); +ASSERT (Y[0bin000010001111] & Y[0bin000011000101] = 0bin0); +ASSERT (Y[0bin000010001111] & Y[0bin000011000110] = 0bin0); +ASSERT (Y[0bin000010001111] & Y[0bin000011000111] = 0bin0); +ASSERT (Y[0bin000010001111] & Y[0bin000011001000] = 0bin0); +ASSERT (Y[0bin000010001111] & Y[0bin000011001001] = 0bin0); +ASSERT (Y[0bin000010001111] & Y[0bin000011001010] = 0bin0); +ASSERT (Y[0bin000010001111] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000010001111] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000010001111] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000010001111] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000010001111] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000010001111] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000010001111] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000010001111] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000010001111] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000010001111] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000010001111] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000010001111] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000010001111] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000010001111] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000010001111] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000010001111] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000010001111] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000010001111] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000010001111] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000010001111] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000010001111] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000010001111] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000010001111] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000010001111] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000010001111] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000010001111] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000010001111] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000010111111] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011000000] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011000001] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011000010] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011000011] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011000100] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011000101] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011000110] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011000111] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011001000] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011001001] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011001010] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011101101] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011101110] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011101111] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011110000] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011110001] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011110010] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011110011] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011110100] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011110101] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011110110] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000010010000] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011000000] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011000001] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011000010] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011000011] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011000100] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011000101] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011000110] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011000111] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011001000] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011001001] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011001010] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011101110] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011101111] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011110000] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011110001] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011110010] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011110011] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011110100] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011110101] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011110110] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100011100] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100011101] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100011110] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100011111] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100100000] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100100001] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100100010] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100100011] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000010010001] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011000001] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011000010] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011000011] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011000100] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011000101] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011000110] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011000111] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011001000] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011001001] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011001010] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011101111] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011110000] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011110001] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011110010] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011110011] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011110100] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011110101] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011110110] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100011101] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100011110] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100011111] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100100000] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100100001] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100100010] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100100011] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000101001011] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000101001100] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000101001101] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000101001110] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000101001111] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000101010000] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000101010001] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000010010010] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000011000010] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000011000011] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000011000100] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000011000101] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000011000110] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000011000111] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000011001000] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000011001001] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000011001010] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000011110000] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000011110001] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000011110010] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000011110011] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000011110100] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000011110101] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000011110110] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100011110] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100011111] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100100000] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100100001] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100100010] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100100011] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000101001100] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000101001101] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000101001110] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000101001111] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000101010000] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000101010001] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000101111010] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000101111011] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000101111100] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000101111101] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000101111110] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000101111111] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000010010011] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000011000011] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000011000100] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000011000101] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000011000110] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000011000111] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000011001000] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000011001001] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000011001010] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000011110001] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000011110010] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000011110011] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000011110100] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000011110101] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000011110110] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100011111] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100100000] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100100001] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100100010] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100100011] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000101001101] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000101001110] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000101001111] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000101010000] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000101010001] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000101111011] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000101111100] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000101111101] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000101111110] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000101111111] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110101001] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110101010] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110101011] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110101100] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110101101] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000010010100] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000011000100] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000011000101] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000011000110] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000011000111] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000011001000] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000011001001] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000011001010] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000011110010] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000011110011] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000011110100] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000011110101] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000011110110] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000100100000] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000100100001] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000100100010] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000100100011] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000101001110] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000101001111] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000101010000] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000101010001] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000101111100] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000101111101] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000101111110] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000101111111] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000110101010] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000110101011] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000110101100] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000110101101] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000111011000] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000111011001] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000111011010] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000111011011] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000111011100] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000010010101] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000011000101] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000011000110] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000011000111] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000011001000] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000011001001] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000011001010] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000011110011] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000011110100] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000011110101] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000011110110] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000100100001] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000100100010] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000100100011] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000101001111] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000101010000] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000101010001] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000101111101] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000101111110] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000101111111] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000110101011] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000110101100] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000110101101] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000111011001] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000111011010] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000111011011] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000111011100] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin001000000111] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin001000001000] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin001000001001] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin001000001010] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000010010110] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000011000110] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000011000111] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000011001000] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000011001001] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000011001010] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000011110100] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000011110101] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000011110110] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000100100010] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000100100011] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000101010000] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000101010001] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000101111110] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000101111111] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000110101100] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000110101101] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000111011010] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000111011011] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000111011100] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001000001000] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001000001001] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001000001010] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001000110110] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001000110111] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001000111000] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001000111001] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000010010111] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000011000111] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000011001000] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000011001001] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000011001010] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000011110101] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000011110110] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000100100011] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000101010001] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000101111111] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000110101101] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000111011011] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000111011100] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001000001001] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001000001010] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001000110111] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001000111000] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001000111001] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001001100101] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001001100110] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001001100111] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001001101000] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000010011000] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000011001000] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000011001001] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000011001010] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000011110110] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000111011100] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001000001010] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001000111000] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001000111001] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001001100110] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001001100111] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001001101000] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001010010100] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001010010101] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001010010110] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000010011001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000011001001] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000011001010] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001000111001] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001001100111] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001001101000] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001010010101] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001010010110] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001011000011] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001011000100] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001011000101] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000010011010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000011001010] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001001101000] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001010010110] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001011000100] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001011000101] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001011110010] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001011110011] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001011110100] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000010011011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000011001011] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001011000101] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001011110011] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001011110100] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001100100001] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001100100010] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001100100011] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000010011100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000011001100] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001011110100] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001100100010] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001100100011] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001101010000] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001101010001] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000010011101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000011001101] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001100100011] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001101010001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001101111111] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001110000000] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000010011110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000011001110] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001110000000] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001110101110] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001110101111] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000010011111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000011001111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001110101111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001111011101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001111011110] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000010100000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000011010000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001111011110] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin010000001100] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin010000001101] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000010100001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000011010001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin010000001101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin010000111011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin010000111100] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000010100010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000011010010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010000111100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010001101010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010001101011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000010100011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000011010011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010001101011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010010011001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010010011010] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000010100100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000011010100] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010010011010] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010011001000] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010011001001] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000010100101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000011010101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010011001001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010011110111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000010100110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000011010110] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010100100110] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000010100111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000011010111] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010101010101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000010101000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000011011000] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010110000100] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000010101001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000011011001] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010110110011] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000010101010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000011011010] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010111100010] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000010101011] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000011011011] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin011000010001] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000010101100] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000011011100] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin011001000000] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000010101101] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000011011101] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin011001101111] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000010101110] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000011011110] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin011010011110] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000010101111] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin000011011111] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin011011001101] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000010110000] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin000011100000] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin011011111100] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000010110001] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin000011100001] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin011100101011] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin000010110010] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin000011100010] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin011101011010] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin000010110011] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin000011100011] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin011110001001] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin000010110100] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin000011100100] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin011110111000] = 0bin0); +ASSERT (Y[0bin000010110101] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin000010110110] & Y[0bin000011100101] = 0bin0); +ASSERT (Y[0bin000010110110] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000010110110] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000010110110] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000010110110] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000010110110] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000010110110] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000010110110] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000010110110] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000010110110] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000010110110] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000010110110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000010110110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000010110110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000010110110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000010110110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000010110110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000010110110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000010110110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000010110110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000010110110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000010110110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000010110110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000010110110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000010110110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000010110110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000010110110] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000010110110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000010110110] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000010110110] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000010110110] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000010110110] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000010110110] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000010110110] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000010110110] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000010110110] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000010110110] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin000010110110] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin000010110110] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin000010110110] & Y[0bin011111100111] = 0bin0); +ASSERT (Y[0bin000010111110] & Y[0bin000011101101] = 0bin0); +ASSERT (Y[0bin000010111110] & Y[0bin000011101110] = 0bin0); +ASSERT (Y[0bin000010111110] & Y[0bin000011101111] = 0bin0); +ASSERT (Y[0bin000010111110] & Y[0bin000011110000] = 0bin0); +ASSERT (Y[0bin000010111110] & Y[0bin000011110001] = 0bin0); +ASSERT (Y[0bin000010111110] & Y[0bin000011110010] = 0bin0); +ASSERT (Y[0bin000010111110] & Y[0bin000011110011] = 0bin0); +ASSERT (Y[0bin000010111110] & Y[0bin000011110100] = 0bin0); +ASSERT (Y[0bin000010111110] & Y[0bin000011110101] = 0bin0); +ASSERT (Y[0bin000010111110] & Y[0bin000011110110] = 0bin0); +ASSERT (Y[0bin000010111110] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000010111110] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000010111110] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000010111110] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000010111110] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000010111110] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000010111110] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000010111110] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000010111110] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000010111110] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000010111110] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000010111110] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000010111110] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000010111110] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000010111110] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000010111110] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000010111110] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000010111110] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000010111110] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000010111110] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000010111110] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000010111110] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000010111110] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000010111110] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000010111110] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000010111110] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000010111110] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000010111110] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000010111110] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000011101110] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000011101111] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000011110000] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000011110001] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000011110010] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000011110011] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000011110100] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000011110101] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000011110110] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100011100] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100011101] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100011110] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100011111] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100100000] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100100001] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100100010] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100100011] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000010111111] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000011101111] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000011110000] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000011110001] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000011110010] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000011110011] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000011110100] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000011110101] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000011110110] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100011101] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100011110] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100011111] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100100000] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100100001] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100100010] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100100011] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000101001011] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000101001100] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000101001101] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000101001110] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000101001111] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000101010000] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000101010001] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011000000] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000011110000] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000011110001] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000011110010] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000011110011] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000011110100] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000011110101] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000011110110] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100011110] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100011111] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100100000] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100100001] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100100010] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100100011] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000101001100] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000101001101] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000101001110] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000101001111] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000101010000] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000101010001] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000101111010] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000101111011] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000101111100] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000101111101] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000101111110] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000101111111] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000011000001] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000011110001] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000011110010] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000011110011] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000011110100] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000011110101] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000011110110] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100011111] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100100000] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100100001] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100100010] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100100011] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000101001101] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000101001110] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000101001111] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000101010000] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000101010001] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000101111011] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000101111100] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000101111101] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000101111110] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000101111111] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110101001] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110101010] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110101011] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110101100] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110101101] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000011000010] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000011110010] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000011110011] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000011110100] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000011110101] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000011110110] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000100100000] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000100100001] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000100100010] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000100100011] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000101001110] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000101001111] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000101010000] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000101010001] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000101111100] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000101111101] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000101111110] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000101111111] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000110101010] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000110101011] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000110101100] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000110101101] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000111011000] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000111011001] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000111011010] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000111011011] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000111011100] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000011000011] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000011110011] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000011110100] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000011110101] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000011110110] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000100100001] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000100100010] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000100100011] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000101001111] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000101010000] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000101010001] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000101111101] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000101111110] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000101111111] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000110101011] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000110101100] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000110101101] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000111011001] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000111011010] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000111011011] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000111011100] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin001000000111] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin001000001000] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin001000001001] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin001000001010] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000011000100] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000011110100] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000011110101] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000011110110] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000100100010] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000100100011] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000101010000] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000101010001] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000101111110] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000101111111] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000110101100] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000110101101] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000111011010] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000111011011] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000111011100] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001000001000] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001000001001] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001000001010] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001000110110] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001000110111] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001000111000] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001000111001] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000011000101] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000011110101] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000011110110] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000100100011] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000101010001] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000101111111] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000110101101] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000111011011] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000111011100] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001000001001] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001000001010] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001000110111] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001000111000] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001000111001] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001001100101] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001001100110] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001001100111] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001001101000] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000011000110] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000011110110] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000111011100] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001000001010] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001000111000] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001000111001] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001001100110] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001001100111] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001001101000] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001010010100] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001010010101] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001010010110] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000011000111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000011110111] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001000111001] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001001100111] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001001101000] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001010010101] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001010010110] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001011000011] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001011000100] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001011000101] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000011001000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000011111000] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001001101000] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001010010110] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001011000100] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001011000101] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001011110010] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001011110011] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001011110100] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000011001001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000011111001] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001011000101] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001011110011] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001011110100] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001100100001] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001100100010] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001100100011] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000011001010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000011111010] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001011110100] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001100100010] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001100100011] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001101010000] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001101010001] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000011001011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000011111011] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001100100011] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001101010001] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001101111111] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001110000000] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000011001100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000011111100] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001110000000] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001110101110] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001110101111] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000011001101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000011111101] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001110101111] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001111011101] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001111011110] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000011001110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000011111110] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001111011110] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin010000001100] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin010000001101] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000011001111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000011111111] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin010000001101] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin010000111011] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin010000111100] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000011010000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000100000000] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010000111100] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010001101010] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010001101011] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000011010001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000100000001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010001101011] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010010011001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010010011010] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000011010010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000100000010] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010010011010] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010011001000] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010011001001] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000011010011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000100000011] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010011001001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010011110111] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000011010100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000100000100] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010100100110] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000011010101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000100000101] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010101010101] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000011010110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000100000110] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010110000100] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000011010111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000100000111] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010110110011] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000011011000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000100001000] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010111100010] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000011011001] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000100001001] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin011000010001] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000011011010] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000100001010] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin011001000000] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000011011011] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000100001011] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin011001101111] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000011011100] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin000100001100] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin011010011110] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000011011101] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin000100001101] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin011011001101] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000011011110] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin000100001110] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin011011111100] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000011011111] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin000100001111] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin011100101011] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin000011100000] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin000100010000] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin011101011010] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin000011100001] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin000100010001] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin011110001001] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin000011100010] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin000100010010] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin011110111000] = 0bin0); +ASSERT (Y[0bin000011100011] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin000011100100] & Y[0bin000100010011] = 0bin0); +ASSERT (Y[0bin000011100100] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011100100] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011100100] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011100100] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000011100100] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000011100100] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000011100100] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000011100100] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000011100100] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000011100100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000011100100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000011100100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000011100100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000011100100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000011100100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000011100100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000011100100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000011100100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000011100100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000011100100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000011100100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000011100100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000011100100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000011100100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000011100100] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000011100100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000011100100] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000011100100] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000011100100] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000011100100] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000011100100] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000011100100] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000011100100] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000011100100] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000011100100] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin000011100100] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin000011100100] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin000011100100] & Y[0bin011111100111] = 0bin0); +ASSERT (Y[0bin000011101101] & Y[0bin000100011100] = 0bin0); +ASSERT (Y[0bin000011101101] & Y[0bin000100011101] = 0bin0); +ASSERT (Y[0bin000011101101] & Y[0bin000100011110] = 0bin0); +ASSERT (Y[0bin000011101101] & Y[0bin000100011111] = 0bin0); +ASSERT (Y[0bin000011101101] & Y[0bin000100100000] = 0bin0); +ASSERT (Y[0bin000011101101] & Y[0bin000100100001] = 0bin0); +ASSERT (Y[0bin000011101101] & Y[0bin000100100010] = 0bin0); +ASSERT (Y[0bin000011101101] & Y[0bin000100100011] = 0bin0); +ASSERT (Y[0bin000011101101] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000011101101] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000011101101] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000011101101] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000011101101] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000011101101] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000011101101] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000011101101] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000011101101] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000011101101] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000011101101] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000011101101] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000011101101] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000011101101] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000011101101] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000011101101] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000011101101] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000011101101] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000011101101] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000011101101] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000011101101] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000011101101] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000011101101] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000011101101] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000011101101] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000011101101] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000011101101] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011101101] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011101101] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011101101] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000100011101] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000100011110] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000100011111] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000100100000] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000100100001] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000100100010] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000100100011] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000101001011] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000101001100] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000101001101] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000101001110] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000101001111] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000101010000] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000101010001] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011101110] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000100011110] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000100011111] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000100100000] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000100100001] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000100100010] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000100100011] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000101001100] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000101001101] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000101001110] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000101001111] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000101010000] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000101010001] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000101111010] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000101111011] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000101111100] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000101111101] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000101111110] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000101111111] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000011101111] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000100011111] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000100100000] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000100100001] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000100100010] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000100100011] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000101001101] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000101001110] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000101001111] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000101010000] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000101010001] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000101111011] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000101111100] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000101111101] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000101111110] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000101111111] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110101001] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110101010] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110101011] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110101100] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110101101] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000011110000] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000100100000] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000100100001] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000100100010] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000100100011] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000101001110] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000101001111] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000101010000] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000101010001] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000101111100] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000101111101] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000101111110] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000101111111] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000110101010] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000110101011] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000110101100] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000110101101] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000111011000] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000111011001] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000111011010] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000111011011] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000111011100] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000011110001] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000100100001] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000100100010] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000100100011] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000101001111] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000101010000] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000101010001] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000101111101] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000101111110] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000101111111] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000110101011] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000110101100] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000110101101] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000111011001] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000111011010] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000111011011] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000111011100] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin001000000111] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin001000001000] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin001000001001] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin001000001010] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000011110010] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000100100010] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000100100011] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000101010000] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000101010001] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000101111110] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000101111111] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000110101100] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000110101101] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000111011010] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000111011011] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000111011100] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001000001000] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001000001001] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001000001010] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001000110110] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001000110111] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001000111000] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001000111001] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000011110011] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000100100011] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000101010001] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000101111111] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000110101101] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000111011011] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000111011100] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001000001001] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001000001010] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001000110111] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001000111000] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001000111001] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001001100101] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001001100110] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001001100111] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001001101000] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000011110100] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000100100100] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000111011100] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001000001010] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001000111000] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001000111001] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001001100110] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001001100111] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001001101000] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001010010100] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001010010101] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001010010110] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000011110101] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000100100101] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001000111001] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001001100111] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001001101000] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001010010101] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001010010110] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001011000011] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001011000100] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001011000101] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000011110110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000100100110] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001001101000] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001010010110] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001011000100] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001011000101] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001011110010] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001011110011] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001011110100] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000011110111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000100100111] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001011000101] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001011110011] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001011110100] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001100100001] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001100100010] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001100100011] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000011111000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000100101000] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001011110100] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001100100010] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001100100011] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001101010000] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001101010001] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000011111001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000100101001] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001100100011] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001101010001] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001101111111] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001110000000] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000011111010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000100101010] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001110000000] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001110101110] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001110101111] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000011111011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000100101011] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001110101111] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001111011101] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001111011110] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000011111100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000100101100] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001111011110] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin010000001100] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin010000001101] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000011111101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000100101101] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin010000001101] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin010000111011] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin010000111100] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000011111110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000100101110] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010000111100] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010001101010] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010001101011] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000011111111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000100101111] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010001101011] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010010011001] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010010011010] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000100000000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000100110000] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010010011010] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010011001000] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010011001001] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000100000001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000100110001] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010011001001] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010011110111] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000100000010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000100110010] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010100100110] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000100000011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000100110011] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010101010101] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000100000100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000100110100] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010110000100] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000100000101] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000100110101] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010110110011] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000100000110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000100110110] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010111100010] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000100000111] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000100110111] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin011000010001] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000100001000] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin000100111000] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin011001000000] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000100001001] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin000100111001] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin011001101111] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000100001010] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin000100111010] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin011010011110] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000100001011] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin000100111011] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin011011001101] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000100001100] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin000100111100] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin011011111100] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000100001101] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin000100111101] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin011100101011] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin000100001110] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin000100111110] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin011101011010] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin000100001111] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin000100111111] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin011110001001] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin000100010000] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin000101000000] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin011110111000] = 0bin0); +ASSERT (Y[0bin000100010001] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin000100010010] & Y[0bin000101000001] = 0bin0); +ASSERT (Y[0bin000100010010] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100010010] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100010010] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100010010] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000100010010] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000100010010] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000100010010] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000100010010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000100010010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000100010010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000100010010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000100010010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000100010010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000100010010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000100010010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000100010010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000100010010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000100010010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000100010010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000100010010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000100010010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000100010010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000100010010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000100010010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000100010010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000100010010] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000100010010] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000100010010] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000100010010] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000100010010] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000100010010] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000100010010] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000100010010] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000100010010] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin000100010010] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin000100010010] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin000100010010] & Y[0bin011111100111] = 0bin0); +ASSERT (Y[0bin000100011100] & Y[0bin000101001011] = 0bin0); +ASSERT (Y[0bin000100011100] & Y[0bin000101001100] = 0bin0); +ASSERT (Y[0bin000100011100] & Y[0bin000101001101] = 0bin0); +ASSERT (Y[0bin000100011100] & Y[0bin000101001110] = 0bin0); +ASSERT (Y[0bin000100011100] & Y[0bin000101001111] = 0bin0); +ASSERT (Y[0bin000100011100] & Y[0bin000101010000] = 0bin0); +ASSERT (Y[0bin000100011100] & Y[0bin000101010001] = 0bin0); +ASSERT (Y[0bin000100011100] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000100011100] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000100011100] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000100011100] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000100011100] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000100011100] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000100011100] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000100011100] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000100011100] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000100011100] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000100011100] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000100011100] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000100011100] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000100011100] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000100011100] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000100011100] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000100011100] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000100011100] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000100011100] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000100011100] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000100011100] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000100011100] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000100011100] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000100011100] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000100011100] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000100011100] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000100011100] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000100011100] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000100011100] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100011100] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000101001100] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000101001101] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000101001110] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000101001111] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000101010000] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000101010001] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000101111010] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000101111011] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000101111100] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000101111101] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000101111110] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000101111111] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100011101] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000101001101] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000101001110] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000101001111] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000101010000] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000101010001] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000101111011] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000101111100] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000101111101] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000101111110] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000101111111] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110101001] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110101010] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110101011] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110101100] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110101101] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000100011110] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000101001110] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000101001111] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000101010000] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000101010001] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000101111100] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000101111101] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000101111110] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000101111111] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000110101010] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000110101011] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000110101100] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000110101101] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000111011000] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000111011001] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000111011010] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000111011011] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000111011100] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000100011111] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000101001111] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000101010000] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000101010001] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000101111101] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000101111110] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000101111111] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000110101011] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000110101100] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000110101101] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000111011001] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000111011010] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000111011011] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000111011100] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin001000000111] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin001000001000] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin001000001001] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin001000001010] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000100100000] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000101010000] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000101010001] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000101111110] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000101111111] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000110101100] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000110101101] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000111011010] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000111011011] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000111011100] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001000001000] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001000001001] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001000001010] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001000110110] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001000110111] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001000111000] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001000111001] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000100100001] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000101010001] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000101111111] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000110101101] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000111011011] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000111011100] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001000001001] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001000001010] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001000110111] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001000111000] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001000111001] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001001100101] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001001100110] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001001100111] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001001101000] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000100100010] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000101010010] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000111011100] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001000001010] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001000111000] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001000111001] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001001100110] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001001100111] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001001101000] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001010010100] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001010010101] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001010010110] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000100100011] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000101010011] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001000111001] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001001100111] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001001101000] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001010010101] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001010010110] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001011000011] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001011000100] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001011000101] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000100100100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000101010100] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001001101000] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001010010110] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001011000100] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001011000101] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001011110010] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001011110011] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001011110100] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000100100101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000101010101] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001011000101] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001011110011] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001011110100] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001100100001] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001100100010] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001100100011] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000100100110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000101010110] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001011110100] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001100100010] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001100100011] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001101010000] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001101010001] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000100100111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000101010111] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001100100011] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001101010001] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001101111111] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001110000000] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000100101000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000101011000] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001110000000] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001110101110] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001110101111] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000100101001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000101011001] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001110101111] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001111011101] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001111011110] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000100101010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000101011010] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001111011110] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin010000001100] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin010000001101] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000100101011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000101011011] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin010000001101] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin010000111011] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin010000111100] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000100101100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000101011100] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010000111100] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010001101010] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010001101011] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000100101101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000101011101] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010001101011] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010010011001] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010010011010] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000100101110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000101011110] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010010011010] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010011001000] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010011001001] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000100101111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000101011111] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010011001001] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010011110111] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000100110000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000101100000] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010100100110] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000100110001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000101100001] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010101010101] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000100110010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000101100010] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010110000100] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000100110011] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin000101100011] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010110110011] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000100110100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin000101100100] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010111100010] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000100110101] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin000101100101] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin011000010001] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000100110110] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin000101100110] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin011001000000] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000100110111] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin000101100111] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin011001101111] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000100111000] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin000101101000] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin011010011110] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000100111001] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin000101101001] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin011011001101] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000100111010] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin000101101010] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin011011111100] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000100111011] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin000101101011] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin011100101011] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin000100111100] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin000101101100] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin011101011010] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin000100111101] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin000101101101] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin011110001001] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin000100111110] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin000101101110] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin011110111000] = 0bin0); +ASSERT (Y[0bin000100111111] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin000101000000] & Y[0bin000101101111] = 0bin0); +ASSERT (Y[0bin000101000000] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000101000000] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000101000000] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000101000000] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000101000000] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000101000000] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000101000000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000101000000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000101000000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000101000000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000101000000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000101000000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000101000000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000101000000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000101000000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000101000000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000101000000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000101000000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000101000000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000101000000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000101000000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000101000000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000101000000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000101000000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000101000000] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000101000000] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000101000000] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000101000000] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000101000000] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000101000000] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000101000000] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000101000000] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000101000000] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin000101000000] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin000101000000] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin000101000000] & Y[0bin011111100111] = 0bin0); +ASSERT (Y[0bin000101001011] & Y[0bin000101111010] = 0bin0); +ASSERT (Y[0bin000101001011] & Y[0bin000101111011] = 0bin0); +ASSERT (Y[0bin000101001011] & Y[0bin000101111100] = 0bin0); +ASSERT (Y[0bin000101001011] & Y[0bin000101111101] = 0bin0); +ASSERT (Y[0bin000101001011] & Y[0bin000101111110] = 0bin0); +ASSERT (Y[0bin000101001011] & Y[0bin000101111111] = 0bin0); +ASSERT (Y[0bin000101001011] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000101001011] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000101001011] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000101001011] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000101001011] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000101001011] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000101001011] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000101001011] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000101001011] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000101001011] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000101001011] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000101001011] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000101001011] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000101001011] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000101001011] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000101001011] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000101001011] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000101001011] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000101001011] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000101001011] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000101001011] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000101001011] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000101001011] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000101001011] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000101001011] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000101001011] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000101001011] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000101001011] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000101001011] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000101001011] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000101111011] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000101111100] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000101111101] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000101111110] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000101111111] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110101001] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110101010] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110101011] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110101100] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110101101] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000101001100] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000101111100] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000101111101] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000101111110] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000101111111] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000110101010] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000110101011] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000110101100] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000110101101] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000111011000] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000111011001] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000111011010] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000111011011] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000111011100] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000101001101] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000101111101] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000101111110] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000101111111] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000110101011] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000110101100] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000110101101] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000111011001] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000111011010] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000111011011] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000111011100] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin001000000111] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin001000001000] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin001000001001] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin001000001010] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000101001110] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000101111110] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000101111111] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000110101100] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000110101101] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000111011010] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000111011011] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000111011100] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001000001000] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001000001001] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001000001010] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001000110110] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001000110111] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001000111000] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001000111001] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000101001111] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000101111111] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000110101101] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000111011011] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000111011100] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001000001001] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001000001010] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001000110111] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001000111000] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001000111001] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001001100101] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001001100110] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001001100111] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001001101000] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000101010000] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000110000000] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000111011100] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001000001010] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001000111000] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001000111001] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001001100110] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001001100111] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001001101000] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001010010100] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001010010101] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001010010110] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000101010001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000110000001] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001000111001] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001001100111] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001001101000] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001010010101] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001010010110] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001011000011] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001011000100] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001011000101] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000101010010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000110000010] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001001101000] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001010010110] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001011000100] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001011000101] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001011110010] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001011110011] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001011110100] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000101010011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000110000011] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001011000101] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001011110011] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001011110100] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001100100001] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001100100010] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001100100011] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000101010100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000110000100] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001011110100] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001100100010] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001100100011] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001101010000] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001101010001] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000101010101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000110000101] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001100100011] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001101010001] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001101111111] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001110000000] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000101010110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000110000110] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001110000000] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001110101110] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001110101111] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000101010111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000110000111] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001110101111] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001111011101] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001111011110] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000101011000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000110001000] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001111011110] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin010000001100] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin010000001101] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000101011001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000110001001] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin010000001101] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin010000111011] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin010000111100] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000101011010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000110001010] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010000111100] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010001101010] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010001101011] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000101011011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000110001011] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010001101011] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010010011001] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010010011010] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000101011100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000110001100] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010010011010] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010011001000] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010011001001] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000101011101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin000110001101] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010011001001] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010011110111] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000101011110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin000110001110] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010100100110] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000101011111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin000110001111] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010101010101] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000101100000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin000110010000] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010110000100] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000101100001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin000110010001] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010110110011] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000101100010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin000110010010] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010111100010] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000101100011] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin000110010011] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin011000010001] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000101100100] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin000110010100] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin011001000000] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000101100101] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin000110010101] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin011001101111] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000101100110] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin000110010110] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin011010011110] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000101100111] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin000110010111] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin011011001101] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000101101000] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin000110011000] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin011011111100] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000101101001] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin000110011001] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin011100101011] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin000101101010] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin000110011010] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin011101011010] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin000101101011] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin000110011011] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin011110001001] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin000101101100] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin000110011100] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin011110111000] = 0bin0); +ASSERT (Y[0bin000101101101] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin000101101110] & Y[0bin000110011101] = 0bin0); +ASSERT (Y[0bin000101101110] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000101101110] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000101101110] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000101101110] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000101101110] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000101101110] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000101101110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000101101110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000101101110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000101101110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000101101110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000101101110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000101101110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000101101110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000101101110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000101101110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000101101110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000101101110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000101101110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000101101110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000101101110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000101101110] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000101101110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000101101110] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000101101110] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000101101110] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000101101110] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000101101110] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000101101110] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000101101110] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000101101110] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000101101110] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin000101101110] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin000101101110] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin000101101110] & Y[0bin011111100111] = 0bin0); +ASSERT (Y[0bin000101111010] & Y[0bin000110101001] = 0bin0); +ASSERT (Y[0bin000101111010] & Y[0bin000110101010] = 0bin0); +ASSERT (Y[0bin000101111010] & Y[0bin000110101011] = 0bin0); +ASSERT (Y[0bin000101111010] & Y[0bin000110101100] = 0bin0); +ASSERT (Y[0bin000101111010] & Y[0bin000110101101] = 0bin0); +ASSERT (Y[0bin000101111010] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000101111010] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000101111010] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000101111010] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000101111010] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000101111010] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000101111010] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000101111010] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000101111010] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000101111010] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000101111010] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000101111010] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000101111010] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000101111010] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000101111010] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000101111010] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000101111010] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000101111010] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000101111010] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000101111010] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000101111010] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000101111010] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000101111010] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000101111010] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000101111010] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000101111010] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000101111010] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000101111010] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000101111010] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000101111010] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000110101010] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000110101011] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000110101100] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000110101101] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000111011000] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000111011001] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000111011010] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000111011011] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000111011100] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000101111011] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000110101011] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000110101100] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000110101101] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000111011001] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000111011010] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000111011011] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000111011100] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin001000000111] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin001000001000] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin001000001001] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin001000001010] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000101111100] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000110101100] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000110101101] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000111011010] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000111011011] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000111011100] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001000001000] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001000001001] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001000001010] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001000110110] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001000110111] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001000111000] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001000111001] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000101111101] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000110101101] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000111011011] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000111011100] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001000001001] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001000001010] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001000110111] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001000111000] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001000111001] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001001100101] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001001100110] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001001100111] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001001101000] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000101111110] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000110101110] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000111011100] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001000001010] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001000111000] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001000111001] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001001100110] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001001100111] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001001101000] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001010010100] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001010010101] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001010010110] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000101111111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000110101111] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001000111001] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001001100111] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001001101000] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001010010101] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001010010110] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001011000011] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001011000100] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001011000101] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000110000000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000110110000] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001001101000] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001010010110] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001011000100] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001011000101] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001011110010] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001011110011] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001011110100] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000110000001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000110110001] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001011000101] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001011110011] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001011110100] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001100100001] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001100100010] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001100100011] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000110000010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin000110110010] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001011110100] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001100100010] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001100100011] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001101010000] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001101010001] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000110000011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin000110110011] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001100100011] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001101010001] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001101111111] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001110000000] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000110000100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin000110110100] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001110000000] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001110101110] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001110101111] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000110000101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin000110110101] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001110101111] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001111011101] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001111011110] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000110000110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin000110110110] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001111011110] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin010000001100] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin010000001101] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000110000111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin000110110111] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin010000001101] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin010000111011] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin010000111100] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000110001000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin000110111000] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010000111100] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010001101010] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010001101011] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000110001001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin000110111001] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010001101011] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010010011001] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010010011010] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000110001010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin000110111010] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010010011010] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010011001000] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010011001001] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000110001011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin000110111011] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010011001001] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010011110111] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000110001100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin000110111100] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010100100110] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000110001101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin000110111101] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010101010101] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000110001110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin000110111110] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010110000100] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000110001111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin000110111111] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010110110011] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000110010000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin000111000000] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010111100010] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000110010001] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin000111000001] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin011000010001] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000110010010] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin000111000010] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin011001000000] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000110010011] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin000111000011] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin011001101111] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000110010100] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin000111000100] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin011010011110] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000110010101] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin000111000101] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin011011001101] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000110010110] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin000111000110] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin011011111100] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000110010111] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin000111000111] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin011100101011] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin000110011000] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin000111001000] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin011101011010] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin000110011001] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin000111001001] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin011110001001] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin000110011010] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin000111001010] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin011110111000] = 0bin0); +ASSERT (Y[0bin000110011011] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin000110011100] & Y[0bin000111001011] = 0bin0); +ASSERT (Y[0bin000110011100] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000110011100] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000110011100] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000110011100] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000110011100] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000110011100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000110011100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000110011100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000110011100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000110011100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000110011100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000110011100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000110011100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000110011100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000110011100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000110011100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000110011100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000110011100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000110011100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000110011100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000110011100] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000110011100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000110011100] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000110011100] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000110011100] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000110011100] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000110011100] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000110011100] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000110011100] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000110011100] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000110011100] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin000110011100] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin000110011100] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin000110011100] & Y[0bin011111100111] = 0bin0); +ASSERT (Y[0bin000110101001] & Y[0bin000111011000] = 0bin0); +ASSERT (Y[0bin000110101001] & Y[0bin000111011001] = 0bin0); +ASSERT (Y[0bin000110101001] & Y[0bin000111011010] = 0bin0); +ASSERT (Y[0bin000110101001] & Y[0bin000111011011] = 0bin0); +ASSERT (Y[0bin000110101001] & Y[0bin000111011100] = 0bin0); +ASSERT (Y[0bin000110101001] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000110101001] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000110101001] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000110101001] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000110101001] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000110101001] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000110101001] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000110101001] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000110101001] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000110101001] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000110101001] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000110101001] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000110101001] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000110101001] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000110101001] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000110101001] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000110101001] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000110101001] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000110101001] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000110101001] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000110101001] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000110101001] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000110101001] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000110101001] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000110101001] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000110101001] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000110101001] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000110101001] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000110101001] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin000111011001] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin000111011010] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin000111011011] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin000111011100] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin001000000111] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin001000001000] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin001000001001] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin001000001010] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000110101010] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin000111011010] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin000111011011] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin000111011100] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001000001000] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001000001001] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001000001010] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001000110110] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001000110111] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001000111000] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001000111001] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000110101011] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin000111011011] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin000111011100] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001000001001] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001000001010] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001000110111] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001000111000] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001000111001] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001001100101] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001001100110] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001001100111] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001001101000] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000110101100] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin000111011100] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001000001010] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001000111000] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001000111001] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001001100110] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001001100111] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001001101000] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001010010100] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001010010101] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001010010110] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000110101101] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin000111011101] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001000111001] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001001100111] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001001101000] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001010010101] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001010010110] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001011000011] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001011000100] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001011000101] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000110101110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin000111011110] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001001101000] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001010010110] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001011000100] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001011000101] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001011110010] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001011110011] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001011110100] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000110101111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin000111011111] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001011000101] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001011110011] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001011110100] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001100100001] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001100100010] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001100100011] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000110110000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin000111100000] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001011110100] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001100100010] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001100100011] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001101010000] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001101010001] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000110110001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin000111100001] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001100100011] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001101010001] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001101111111] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001110000000] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000110110010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin000111100010] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001110000000] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001110101110] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001110101111] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000110110011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin000111100011] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001110101111] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001111011101] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001111011110] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000110110100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin000111100100] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001111011110] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin010000001100] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin010000001101] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000110110101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin000111100101] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin010000001101] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin010000111011] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin010000111100] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000110110110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin000111100110] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010000111100] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010001101010] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010001101011] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000110110111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin000111100111] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010001101011] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010010011001] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010010011010] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000110111000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin000111101000] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010010011010] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010011001000] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010011001001] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000110111001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin000111101001] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010011001001] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010011110111] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000110111010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin000111101010] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010100100110] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000110111011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin000111101011] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010101010101] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000110111100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin000111101100] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010110000100] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000110111101] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin000111101101] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010110110011] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000110111110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin000111101110] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010111100010] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000110111111] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin000111101111] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin011000010001] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000111000000] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin000111110000] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin011001000000] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000111000001] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin000111110001] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin011001101111] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000111000010] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin000111110010] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin011010011110] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000111000011] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin000111110011] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin011011001101] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000111000100] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin000111110100] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin011011111100] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000111000101] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin000111110101] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin011100101011] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin000111000110] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin000111110110] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin011101011010] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin000111000111] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin000111110111] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin011110001001] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin000111001000] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin000111111000] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin011110111000] = 0bin0); +ASSERT (Y[0bin000111001001] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin000111001010] & Y[0bin000111111001] = 0bin0); +ASSERT (Y[0bin000111001010] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000111001010] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000111001010] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000111001010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000111001010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000111001010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000111001010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000111001010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000111001010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000111001010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000111001010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000111001010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000111001010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000111001010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000111001010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000111001010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000111001010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000111001010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000111001010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000111001010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000111001010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000111001010] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000111001010] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000111001010] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000111001010] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000111001010] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000111001010] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000111001010] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000111001010] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000111001010] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin000111001010] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin000111001010] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin000111001010] & Y[0bin011111100111] = 0bin0); +ASSERT (Y[0bin000111011000] & Y[0bin001000000111] = 0bin0); +ASSERT (Y[0bin000111011000] & Y[0bin001000001000] = 0bin0); +ASSERT (Y[0bin000111011000] & Y[0bin001000001001] = 0bin0); +ASSERT (Y[0bin000111011000] & Y[0bin001000001010] = 0bin0); +ASSERT (Y[0bin000111011000] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000111011000] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000111011000] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000111011000] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000111011000] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000111011000] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000111011000] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000111011000] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000111011000] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000111011000] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000111011000] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000111011000] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000111011000] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000111011000] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000111011000] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000111011000] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000111011000] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000111011000] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000111011000] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000111011000] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000111011000] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000111011000] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000111011000] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000111011000] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000111011000] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000111011000] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000111011000] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000111011000] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000111011000] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001000001000] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001000001001] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001000001010] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001000110110] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001000110111] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001000111000] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001000111001] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000111011001] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001000001001] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001000001010] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001000110111] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001000111000] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001000111001] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001001100101] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001001100110] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001001100111] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001001101000] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000111011010] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001000001010] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001000111000] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001000111001] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001001100110] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001001100111] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001001101000] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001010010100] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001010010101] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001010010110] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000111011011] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001000001011] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001000111001] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001001100111] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001001101000] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001010010101] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001010010110] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001011000011] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001011000100] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001011000101] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000111011100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001000001100] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001001101000] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001010010110] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001011000100] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001011000101] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001011110010] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001011110011] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001011110100] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000111011101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001000001101] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001011000101] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001011110011] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001011110100] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001100100001] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001100100010] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001100100011] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000111011110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001000001110] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001011110100] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001100100010] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001100100011] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001101010000] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001101010001] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000111011111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001000001111] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001100100011] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001101010001] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001101111111] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001110000000] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000111100000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001000010000] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001110000000] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001110101110] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001110101111] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000111100001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001000010001] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001110101111] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001111011101] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001111011110] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000111100010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001000010010] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001111011110] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin010000001100] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin010000001101] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000111100011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001000010011] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin010000001101] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin010000111011] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin010000111100] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000111100100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001000010100] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010000111100] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010001101010] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010001101011] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000111100101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001000010101] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010001101011] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010010011001] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010010011010] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000111100110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001000010110] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010010011010] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010011001000] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010011001001] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000111100111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001000010111] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010011001001] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010011110111] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000111101000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001000011000] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010100100110] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000111101001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001000011001] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010101010101] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000111101010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001000011010] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010110000100] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000111101011] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001000011011] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010110110011] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000111101100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001000011100] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010111100010] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000111101101] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001000011101] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin011000010001] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000111101110] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001000011110] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin011001000000] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000111101111] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001000011111] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin011001101111] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000111110000] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001000100000] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin011010011110] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000111110001] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001000100001] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin011011001101] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000111110010] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001000100010] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin011011111100] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000111110011] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001000100011] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin011100101011] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin000111110100] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin001000100100] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin011101011010] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin000111110101] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin001000100101] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin011110001001] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin000111110110] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin001000100110] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin011110111000] = 0bin0); +ASSERT (Y[0bin000111110111] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin000111111000] & Y[0bin001000100111] = 0bin0); +ASSERT (Y[0bin000111111000] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin000111111000] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin000111111000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin000111111000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin000111111000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin000111111000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin000111111000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin000111111000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin000111111000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin000111111000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin000111111000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin000111111000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin000111111000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin000111111000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin000111111000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin000111111000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin000111111000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin000111111000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin000111111000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin000111111000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin000111111000] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin000111111000] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin000111111000] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin000111111000] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin000111111000] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin000111111000] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin000111111000] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin000111111000] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin000111111000] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin000111111000] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin000111111000] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin000111111000] & Y[0bin011111100111] = 0bin0); +ASSERT (Y[0bin001000000111] & Y[0bin001000110110] = 0bin0); +ASSERT (Y[0bin001000000111] & Y[0bin001000110111] = 0bin0); +ASSERT (Y[0bin001000000111] & Y[0bin001000111000] = 0bin0); +ASSERT (Y[0bin001000000111] & Y[0bin001000111001] = 0bin0); +ASSERT (Y[0bin001000000111] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin001000000111] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin001000000111] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin001000000111] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin001000000111] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin001000000111] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin001000000111] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin001000000111] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin001000000111] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin001000000111] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin001000000111] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin001000000111] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin001000000111] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin001000000111] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin001000000111] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin001000000111] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin001000000111] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin001000000111] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin001000000111] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin001000000111] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin001000000111] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin001000000111] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin001000000111] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin001000000111] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin001000000111] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin001000000111] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin001000000111] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin001000000111] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001000110111] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001000111000] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001000111001] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001001100101] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001001100110] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001001100111] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001001101000] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001000001000] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001000111000] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001000111001] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001001100110] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001001100111] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001001101000] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001010010100] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001010010101] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001010010110] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001000001001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001000111001] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001001100111] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001001101000] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001010010101] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001010010110] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001011000011] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001011000100] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001011000101] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001000001010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001000111010] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001001101000] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001010010110] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001011000100] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001011000101] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001011110010] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001011110011] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001011110100] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001000001011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001000111011] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001011000101] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001011110011] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001011110100] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001100100001] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001100100010] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001100100011] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001000001100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001000111100] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001011110100] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001100100010] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001100100011] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001101010000] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001101010001] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001000001101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001000111101] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001100100011] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001101010001] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001101111111] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001110000000] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001000001110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001000111110] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001110000000] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001110101110] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001110101111] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001000001111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001000111111] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001110101111] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001111011101] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001111011110] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001000010000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001001000000] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001111011110] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin010000001100] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin010000001101] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001000010001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001001000001] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin010000001101] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin010000111011] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin010000111100] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001000010010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001001000010] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010000111100] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010001101010] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010001101011] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001000010011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001001000011] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010001101011] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010010011001] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010010011010] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001000010100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001001000100] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010010011010] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010011001000] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010011001001] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001000010101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001001000101] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010011001001] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010011110111] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001000010110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001001000110] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010100100110] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001000010111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001001000111] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010101010101] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001000011000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001001001000] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010110000100] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001000011001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001001001001] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010110110011] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001000011010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001001001010] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010111100010] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001000011011] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001001001011] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin011000010001] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001000011100] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001001001100] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin011001000000] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001000011101] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001001001101] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin011001101111] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001000011110] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001001001110] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin011010011110] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001000011111] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001001001111] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin011011001101] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001000100000] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001001010000] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin011011111100] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001000100001] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin001001010001] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin011100101011] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin001000100010] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin001001010010] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin011101011010] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin001000100011] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin001001010011] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin011110001001] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin001000100100] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin001001010100] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin011110111000] = 0bin0); +ASSERT (Y[0bin001000100101] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin001000100110] & Y[0bin001001010101] = 0bin0); +ASSERT (Y[0bin001000100110] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001000100110] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001000100110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001000100110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001000100110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001000100110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001000100110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001000100110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001000100110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001000100110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001000100110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001000100110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001000100110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001000100110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001000100110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001000100110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001000100110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001000100110] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001000100110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001000100110] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001000100110] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001000100110] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001000100110] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001000100110] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001000100110] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001000100110] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001000100110] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001000100110] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin001000100110] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin001000100110] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin001000100110] & Y[0bin011111100111] = 0bin0); +ASSERT (Y[0bin001000110110] & Y[0bin001001100101] = 0bin0); +ASSERT (Y[0bin001000110110] & Y[0bin001001100110] = 0bin0); +ASSERT (Y[0bin001000110110] & Y[0bin001001100111] = 0bin0); +ASSERT (Y[0bin001000110110] & Y[0bin001001101000] = 0bin0); +ASSERT (Y[0bin001000110110] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin001000110110] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin001000110110] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin001000110110] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin001000110110] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin001000110110] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin001000110110] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin001000110110] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin001000110110] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin001000110110] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin001000110110] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin001000110110] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin001000110110] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin001000110110] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin001000110110] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin001000110110] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin001000110110] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin001000110110] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin001000110110] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin001000110110] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin001000110110] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin001000110110] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin001000110110] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001000110110] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001000110110] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001000110110] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001000110110] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001001100110] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001001100111] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001001101000] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001010010100] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001010010101] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001010010110] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001000110111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001001100111] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001001101000] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001010010101] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001010010110] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001011000011] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001011000100] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001011000101] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001000111000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001001101000] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001010010110] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001011000100] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001011000101] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001011110010] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001011110011] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001011110100] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001000111001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001001101001] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001011000101] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001011110011] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001011110100] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001100100001] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001100100010] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001100100011] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001000111010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001001101010] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001011110100] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001100100010] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001100100011] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001101010000] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001101010001] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001000111011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001001101011] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001100100011] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001101010001] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001101111111] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001110000000] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001000111100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001001101100] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001110000000] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001110101110] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001110101111] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001000111101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001001101101] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001110101111] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001111011101] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001111011110] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001000111110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001001101110] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001111011110] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin010000001100] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin010000001101] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001000111111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001001101111] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin010000001101] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin010000111011] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin010000111100] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001001000000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001001110000] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010000111100] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010001101010] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010001101011] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001001000001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001001110001] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010001101011] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010010011001] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010010011010] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001001000010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001001110010] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010010011010] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010011001000] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010011001001] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001001000011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001001110011] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010011001001] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010011110111] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001001000100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001001110100] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010100100110] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001001000101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001001110101] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010101010101] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001001000110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001001110110] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010110000100] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001001000111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001001110111] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010110110011] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001001001000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001001111000] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010111100010] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001001001001] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001001111001] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin011000010001] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001001001010] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001001111010] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin011001000000] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001001001011] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001001111011] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin011001101111] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001001001100] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001001111100] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin011010011110] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001001001101] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001001111101] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin011011001101] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001001001110] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001001111110] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin011011111100] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001001001111] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin001001111111] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin011100101011] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin001001010000] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin001010000000] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin011101011010] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin001001010001] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin001010000001] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin011110001001] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin001001010010] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin001010000010] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin011110111000] = 0bin0); +ASSERT (Y[0bin001001010011] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin001001010100] & Y[0bin001010000011] = 0bin0); +ASSERT (Y[0bin001001010100] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001001010100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001001010100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001001010100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001001010100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001001010100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001001010100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001001010100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001001010100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001001010100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001001010100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001001010100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001001010100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001001010100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001001010100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001001010100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001001010100] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001001010100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001001010100] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001001010100] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001001010100] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001001010100] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001001010100] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001001010100] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001001010100] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001001010100] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001001010100] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin001001010100] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin001001010100] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin001001010100] & Y[0bin011111100111] = 0bin0); +ASSERT (Y[0bin001001100101] & Y[0bin001010010100] = 0bin0); +ASSERT (Y[0bin001001100101] & Y[0bin001010010101] = 0bin0); +ASSERT (Y[0bin001001100101] & Y[0bin001010010110] = 0bin0); +ASSERT (Y[0bin001001100101] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin001001100101] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin001001100101] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin001001100101] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin001001100101] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin001001100101] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin001001100101] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin001001100101] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin001001100101] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin001001100101] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin001001100101] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin001001100101] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin001001100101] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin001001100101] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin001001100101] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001001100101] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001001100101] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001001100101] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001001100101] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001001100101] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001001100101] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001001100101] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001001100101] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001001100101] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001001100101] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001001100101] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001001100101] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001010010101] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001010010110] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001011000011] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001011000100] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001011000101] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001001100110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001010010110] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001011000100] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001011000101] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001011110010] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001011110011] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001011110100] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001001100111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001010010111] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001011000101] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001011110011] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001011110100] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001100100001] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001100100010] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001100100011] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001001101000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001010011000] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001011110100] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001100100010] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001100100011] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001101010000] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001101010001] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001001101001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001010011001] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001100100011] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001101010001] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001101111111] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001110000000] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001001101010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001010011010] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001110000000] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001110101110] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001110101111] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001001101011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001010011011] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001110101111] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001111011101] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001111011110] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001001101100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001010011100] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001111011110] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin010000001100] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin010000001101] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001001101101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001010011101] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin010000001101] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin010000111011] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin010000111100] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001001101110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001010011110] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010000111100] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010001101010] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010001101011] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001001101111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001010011111] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010001101011] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010010011001] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010010011010] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001001110000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001010100000] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010010011010] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010011001000] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010011001001] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001001110001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001010100001] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010011001001] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010011110111] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001001110010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001010100010] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010100100110] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001001110011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001010100011] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010101010101] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001001110100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001010100100] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010110000100] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001001110101] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001010100101] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010110110011] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001001110110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001010100110] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010111100010] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001001110111] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001010100111] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin011000010001] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001001111000] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001010101000] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin011001000000] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001001111001] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001010101001] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin011001101111] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001001111010] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001010101010] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin011010011110] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001001111011] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001010101011] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin011011001101] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001001111100] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin001010101100] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin011011111100] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001001111101] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin001010101101] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin011100101011] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin001001111110] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin001010101110] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin011101011010] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin001001111111] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin001010101111] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin011110001001] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin001010000000] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin001010110000] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin011110111000] = 0bin0); +ASSERT (Y[0bin001010000001] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin001010000010] & Y[0bin001010110001] = 0bin0); +ASSERT (Y[0bin001010000010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001010000010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001010000010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001010000010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001010000010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001010000010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001010000010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001010000010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001010000010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001010000010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001010000010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001010000010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001010000010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001010000010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001010000010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001010000010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001010000010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001010000010] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001010000010] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001010000010] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001010000010] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001010000010] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001010000010] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001010000010] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001010000010] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001010000010] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin001010000010] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin001010000010] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin001010000010] & Y[0bin011111100111] = 0bin0); +ASSERT (Y[0bin001010010100] & Y[0bin001011000011] = 0bin0); +ASSERT (Y[0bin001010010100] & Y[0bin001011000100] = 0bin0); +ASSERT (Y[0bin001010010100] & Y[0bin001011000101] = 0bin0); +ASSERT (Y[0bin001010010100] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin001010010100] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin001010010100] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin001010010100] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin001010010100] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin001010010100] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin001010010100] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin001010010100] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin001010010100] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin001010010100] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin001010010100] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001010010100] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001010010100] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001010010100] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001010010100] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001010010100] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001010010100] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001010010100] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001010010100] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001010010100] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001010010100] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001010010100] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001010010100] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001010010100] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001010010100] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001010010100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001011000100] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001011000101] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001011110010] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001011110011] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001011110100] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001010010101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001011000101] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001011110011] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001011110100] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001100100001] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001100100010] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001100100011] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001010010110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001011000110] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001011110100] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001100100010] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001100100011] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001101010000] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001101010001] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001010010111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001011000111] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001100100011] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001101010001] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001101111111] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001110000000] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001010011000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001011001000] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001110000000] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001110101110] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001110101111] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001010011001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001011001001] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001110101111] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001111011101] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001111011110] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001010011010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001011001010] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001111011110] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin010000001100] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin010000001101] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001010011011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001011001011] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin010000001101] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin010000111011] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin010000111100] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001010011100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001011001100] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010000111100] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010001101010] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010001101011] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001010011101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001011001101] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010001101011] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010010011001] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010010011010] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001010011110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001011001110] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010010011010] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010011001000] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010011001001] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001010011111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001011001111] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010011001001] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010011110111] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001010100000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001011010000] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010100100110] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001010100001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001011010001] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010101010101] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001010100010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001011010010] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010110000100] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001010100011] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001011010011] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010110110011] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001010100100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001011010100] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010111100010] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001010100101] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001011010101] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin011000010001] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001010100110] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001011010110] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin011001000000] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001010100111] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001011010111] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin011001101111] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001010101000] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001011011000] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin011010011110] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001010101001] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin001011011001] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin011011001101] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001010101010] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin001011011010] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin011011111100] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001010101011] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin001011011011] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin011100101011] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin001010101100] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin001011011100] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin011101011010] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin001010101101] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin001011011101] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin011110001001] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin001010101110] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin001011011110] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin011110111000] = 0bin0); +ASSERT (Y[0bin001010101111] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin001010110000] & Y[0bin001011011111] = 0bin0); +ASSERT (Y[0bin001010110000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001010110000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001010110000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001010110000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001010110000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001010110000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001010110000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001010110000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001010110000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001010110000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001010110000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001010110000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001010110000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001010110000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001010110000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001010110000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001010110000] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001010110000] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001010110000] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001010110000] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001010110000] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001010110000] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001010110000] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001010110000] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001010110000] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin001010110000] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin001010110000] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin001010110000] & Y[0bin011111100111] = 0bin0); +ASSERT (Y[0bin001011000011] & Y[0bin001011110010] = 0bin0); +ASSERT (Y[0bin001011000011] & Y[0bin001011110011] = 0bin0); +ASSERT (Y[0bin001011000011] & Y[0bin001011110100] = 0bin0); +ASSERT (Y[0bin001011000011] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin001011000011] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin001011000011] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin001011000011] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin001011000011] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin001011000011] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin001011000011] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin001011000011] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001011000011] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001011000011] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001011000011] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001011000011] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001011000011] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001011000011] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001011000011] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001011000011] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001011000011] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001011000011] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001011000011] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001011000011] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001011000011] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001011000011] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001011000011] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001011000011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001011000011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001011110011] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001011110100] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001100100001] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001100100010] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001100100011] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001011000100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001011110100] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001100100010] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001100100011] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001101010000] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001101010001] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001011000101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001011110101] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001100100011] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001101010001] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001101111111] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001110000000] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001011000110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001011110110] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001110000000] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001110101110] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001110101111] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001011000111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001011110111] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001110101111] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001111011101] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001111011110] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001011001000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001011111000] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001111011110] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin010000001100] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin010000001101] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001011001001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001011111001] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin010000001101] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin010000111011] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin010000111100] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001011001010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001011111010] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010000111100] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010001101010] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010001101011] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001011001011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001011111011] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010001101011] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010010011001] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010010011010] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001011001100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001011111100] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010010011010] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010011001000] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010011001001] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001011001101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001011111101] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010011001001] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010011110111] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001011001110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001011111110] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010100100110] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001011001111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001011111111] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010101010101] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001011010000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001100000000] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010110000100] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001011010001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001100000001] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010110110011] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001011010010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001100000010] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010111100010] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001011010011] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001100000011] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin011000010001] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001011010100] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001100000100] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin011001000000] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001011010101] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001100000101] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin011001101111] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001011010110] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin001100000110] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin011010011110] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001011010111] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin001100000111] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin011011001101] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001011011000] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin001100001000] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin011011111100] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001011011001] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin001100001001] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin011100101011] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin001011011010] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin001100001010] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin011101011010] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin001011011011] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin001100001011] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin011110001001] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin001011011100] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin001100001100] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin011110111000] = 0bin0); +ASSERT (Y[0bin001011011101] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin001011011110] & Y[0bin001100001101] = 0bin0); +ASSERT (Y[0bin001011011110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001011011110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001011011110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001011011110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001011011110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001011011110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001011011110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001011011110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001011011110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001011011110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001011011110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001011011110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001011011110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001011011110] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001011011110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001011011110] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001011011110] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001011011110] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001011011110] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001011011110] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001011011110] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001011011110] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001011011110] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001011011110] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin001011011110] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin001011011110] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin001011011110] & Y[0bin011111100111] = 0bin0); +ASSERT (Y[0bin001011110010] & Y[0bin001100100001] = 0bin0); +ASSERT (Y[0bin001011110010] & Y[0bin001100100010] = 0bin0); +ASSERT (Y[0bin001011110010] & Y[0bin001100100011] = 0bin0); +ASSERT (Y[0bin001011110010] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin001011110010] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin001011110010] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin001011110010] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin001011110010] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin001011110010] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001011110010] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001011110010] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001011110010] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001011110010] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001011110010] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001011110010] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001011110010] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001011110010] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001011110010] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001011110010] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001011110010] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001011110010] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001011110010] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001011110010] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001011110010] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001011110010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001011110010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001011110010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001011110011] & Y[0bin001100100010] = 0bin0); +ASSERT (Y[0bin001011110011] & Y[0bin001100100011] = 0bin0); +ASSERT (Y[0bin001011110011] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin001011110011] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin001011110011] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin001011110011] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin001011110011] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin001011110011] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001011110011] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001011110011] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001011110011] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001011110011] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001011110011] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001011110011] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001011110011] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001011110011] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001011110011] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001011110011] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001011110011] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001011110011] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001011110011] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001011110011] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001011110011] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001011110011] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001011110011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001011110011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001011110011] & Y[0bin001101010000] = 0bin0); +ASSERT (Y[0bin001011110011] & Y[0bin001101010001] = 0bin0); +ASSERT (Y[0bin001011110011] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin001011110011] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin001011110011] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin001011110011] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin001011110011] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin001011110011] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001011110011] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001011110011] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001011110011] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001011110011] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001011110011] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001011110011] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001011110011] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001011110011] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001011110011] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001011110011] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001011110011] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001011110011] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001011110011] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001011110011] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001011110011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001011110011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001011110011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001011110011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001100100011] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001101010001] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001101111111] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001110000000] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001011110100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001100100100] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001110000000] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001110101110] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001110101111] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001011110101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001100100101] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001110101111] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001111011101] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001111011110] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001011110110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001100100110] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001111011110] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin010000001100] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin010000001101] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001011110111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001100100111] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin010000001101] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin010000111011] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin010000111100] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001011111000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001100101000] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010000111100] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010001101010] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010001101011] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001011111001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001100101001] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010001101011] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010010011001] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010010011010] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001011111010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001100101010] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010010011010] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010011001000] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010011001001] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001011111011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001100101011] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010011001001] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010011110111] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001011111100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001100101100] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010100100110] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001011111101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001100101101] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010101010101] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001011111110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001100101110] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010110000100] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001011111111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001100101111] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010110110011] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001100000000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001100110000] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010111100010] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001100000001] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001100110001] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin011000010001] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001100000010] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin001100110010] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin011001000000] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001100000011] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin001100110011] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin011001101111] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001100000100] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin001100110100] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin011010011110] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001100000101] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin001100110101] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin011011001101] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001100000110] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin001100110110] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin011011111100] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001100000111] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin001100110111] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin011100101011] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin001100001000] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin001100111000] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin011101011010] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin001100001001] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin001100111001] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin011110001001] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin001100001010] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin001100001011] & Y[0bin001100111010] = 0bin0); +ASSERT (Y[0bin001100001011] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001100001011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001100001011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001100001011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001100001011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001100001011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001100001011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001100001011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001100001011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001100001011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001100001011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001100001011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001100001011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001100001011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001100001011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001100001011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001100001011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001100001011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001100001011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001100001011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001100001011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001100001011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001100001011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001100001011] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001100001011] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001100001011] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001100001011] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001100001011] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001100001011] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001100001011] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001100001011] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001100001011] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001100001011] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001100001011] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001100001011] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001100001011] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001100001011] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001100001011] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001100001011] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001100001011] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001100001011] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001100001011] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001100001011] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001100001011] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin001100001011] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001100001011] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin001100001011] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin001100001011] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin001100001011] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin001100001011] & Y[0bin011110111000] = 0bin0); +ASSERT (Y[0bin001100001011] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin001100001100] & Y[0bin001100111011] = 0bin0); +ASSERT (Y[0bin001100001100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001100001100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001100001100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001100001100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001100001100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001100001100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001100001100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001100001100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001100001100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001100001100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001100001100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001100001100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001100001100] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001100001100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001100001100] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001100001100] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001100001100] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001100001100] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001100001100] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001100001100] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001100001100] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001100001100] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001100001100] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin001100001100] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin001100001100] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin001100001100] & Y[0bin011111100111] = 0bin0); +ASSERT (Y[0bin001100100001] & Y[0bin001101010000] = 0bin0); +ASSERT (Y[0bin001100100001] & Y[0bin001101010001] = 0bin0); +ASSERT (Y[0bin001100100001] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin001100100001] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin001100100001] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin001100100001] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin001100100001] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin001100100001] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001100100001] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001100100001] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001100100001] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001100100001] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001100100001] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001100100001] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001100100001] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001100100001] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001100100001] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001100100001] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001100100001] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001100100001] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001100100001] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001100100001] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001100100001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001100100001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001100100001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001100100001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001100100010] & Y[0bin001101010001] = 0bin0); +ASSERT (Y[0bin001100100010] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin001100100010] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin001100100010] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin001100100010] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin001100100010] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin001100100010] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001100100010] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001100100010] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001100100010] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001100100010] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001100100010] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001100100010] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001100100010] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001100100010] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001100100010] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001100100010] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001100100010] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001100100010] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001100100010] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001100100010] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001100100010] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001100100010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001100100010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001100100010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001100100010] & Y[0bin001101111111] = 0bin0); +ASSERT (Y[0bin001100100010] & Y[0bin001110000000] = 0bin0); +ASSERT (Y[0bin001100100010] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin001100100010] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin001100100010] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin001100100010] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin001100100010] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001100100010] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001100100010] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001100100010] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001100100010] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001100100010] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001100100010] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001100100010] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001100100010] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001100100010] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001100100010] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001100100010] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001100100010] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001100100010] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001100100010] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001100100010] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001100100010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001100100010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001100100010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001101010010] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001110000000] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001110101110] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001110101111] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001100100011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001101010011] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001110101111] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001111011101] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001111011110] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001100100100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001101010100] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001111011110] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin010000001100] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin010000001101] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001100100101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001101010101] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin010000001101] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin010000111011] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin010000111100] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001100100110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001101010110] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010000111100] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010001101010] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010001101011] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001100100111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001101010111] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010001101011] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010010011001] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010010011010] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001100101000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001101011000] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010010011010] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010011001000] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010011001001] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001100101001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001101011001] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010011001001] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010011110111] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001100101010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001101011010] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010100100110] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001100101011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001101011011] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010101010101] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001100101100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001101011100] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010110000100] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001100101101] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin001101011101] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010110110011] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001100101110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin001101011110] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010111100010] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001100101111] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin001101011111] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin011000010001] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001100110000] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin001101100000] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin011001000000] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001100110001] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin001101100001] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin011001101111] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001100110010] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin001101100010] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin011010011110] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001100110011] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin001101100011] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin011011001101] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001100110100] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin001101100100] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin011011111100] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001100110101] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin001101100101] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin011100101011] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin001100110110] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin001101100110] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin011101011010] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin001100110111] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin001101100111] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin011110001001] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin001100111000] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin001100111001] & Y[0bin001101101000] = 0bin0); +ASSERT (Y[0bin001100111001] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001100111001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001100111001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001100111001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001100111001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001100111001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001100111001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001100111001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001100111001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001100111001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001100111001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001100111001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001100111001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001100111001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001100111001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001100111001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001100111001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001100111001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001100111001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001100111001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001100111001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001100111001] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001100111001] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001100111001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001100111001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001100111001] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001100111001] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001100111001] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001100111001] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001100111001] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001100111001] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001100111001] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001100111001] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001100111001] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001100111001] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001100111001] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001100111001] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001100111001] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001100111001] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001100111001] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001100111001] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001100111001] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin001100111001] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001100111001] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin001100111001] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin001100111001] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin001100111001] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin001100111001] & Y[0bin011110111000] = 0bin0); +ASSERT (Y[0bin001100111001] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin001100111010] & Y[0bin001101101001] = 0bin0); +ASSERT (Y[0bin001100111010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001100111010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001100111010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001100111010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001100111010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001100111010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001100111010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001100111010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001100111010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001100111010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001100111010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001100111010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001100111010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001100111010] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001100111010] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001100111010] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001100111010] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001100111010] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001100111010] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001100111010] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001100111010] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001100111010] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin001100111010] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin001100111010] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin001100111010] & Y[0bin011111100111] = 0bin0); +ASSERT (Y[0bin001101010000] & Y[0bin001101111111] = 0bin0); +ASSERT (Y[0bin001101010000] & Y[0bin001110000000] = 0bin0); +ASSERT (Y[0bin001101010000] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin001101010000] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin001101010000] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin001101010000] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin001101010000] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001101010000] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001101010000] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001101010000] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001101010000] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001101010000] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001101010000] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001101010000] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001101010000] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001101010000] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001101010000] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001101010000] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001101010000] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001101010000] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001101010000] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001101010000] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001101010000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001101010000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001101010000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001101010001] & Y[0bin001110000000] = 0bin0); +ASSERT (Y[0bin001101010001] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin001101010001] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin001101010001] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin001101010001] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin001101010001] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001101010001] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001101010001] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001101010001] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001101010001] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001101010001] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001101010001] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001101010001] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001101010001] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001101010001] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001101010001] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001101010001] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001101010001] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001101010001] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001101010001] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001101010001] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001101010001] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001101010001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001101010001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001101010001] & Y[0bin001110101110] = 0bin0); +ASSERT (Y[0bin001101010001] & Y[0bin001110101111] = 0bin0); +ASSERT (Y[0bin001101010001] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin001101010001] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin001101010001] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin001101010001] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001101010001] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001101010001] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001101010001] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001101010001] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001101010001] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001101010001] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001101010001] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001101010001] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001101010001] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001101010001] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001101010001] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001101010001] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001101010001] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001101010001] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001101010001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001101010001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001101010001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001101010001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001110000001] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001110101111] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001111011101] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001111011110] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001101010010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001110000010] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001111011110] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin010000001100] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin010000001101] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001101010011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001110000011] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin010000001101] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin010000111011] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin010000111100] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001101010100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001110000100] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010000111100] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010001101010] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010001101011] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001101010101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001110000101] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010001101011] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010010011001] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010010011010] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001101010110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001110000110] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010010011010] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010011001000] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010011001001] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001101010111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin001110000111] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010011001001] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010011110111] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001101011000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin001110001000] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010100100110] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001101011001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin001110001001] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010101010101] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001101011010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin001110001010] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010110000100] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001101011011] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin001110001011] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010110110011] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001101011100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin001110001100] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010111100010] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001101011101] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin001110001101] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin011000010001] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001101011110] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin001110001110] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin011001000000] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001101011111] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin001110001111] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin011001101111] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001101100000] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin001110010000] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin011010011110] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001101100001] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin001110010001] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin011011001101] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001101100010] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin001110010010] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin011011111100] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001101100011] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin001110010011] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin011100101011] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin001101100100] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin001110010100] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin011101011010] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin001101100101] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin001110010101] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin011110001001] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin001101100110] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin001101100111] & Y[0bin001110010110] = 0bin0); +ASSERT (Y[0bin001101100111] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001101100111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001101100111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001101100111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001101100111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001101100111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001101100111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001101100111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001101100111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001101100111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001101100111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001101100111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001101100111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001101100111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001101100111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001101100111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001101100111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001101100111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001101100111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001101100111] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001101100111] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001101100111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001101100111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001101100111] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001101100111] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001101100111] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001101100111] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001101100111] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001101100111] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001101100111] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001101100111] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001101100111] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001101100111] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001101100111] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001101100111] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001101100111] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001101100111] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001101100111] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001101100111] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001101100111] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin001101100111] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001101100111] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin001101100111] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin001101100111] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin001101100111] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin001101100111] & Y[0bin011110111000] = 0bin0); +ASSERT (Y[0bin001101100111] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin001101101000] & Y[0bin001110010111] = 0bin0); +ASSERT (Y[0bin001101101000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001101101000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001101101000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001101101000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001101101000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001101101000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001101101000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001101101000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001101101000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001101101000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001101101000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001101101000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001101101000] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001101101000] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001101101000] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001101101000] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001101101000] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001101101000] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001101101000] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001101101000] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001101101000] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin001101101000] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin001101101000] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin001101101000] & Y[0bin011111100111] = 0bin0); +ASSERT (Y[0bin001101111111] & Y[0bin001110101110] = 0bin0); +ASSERT (Y[0bin001101111111] & Y[0bin001110101111] = 0bin0); +ASSERT (Y[0bin001101111111] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin001101111111] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin001101111111] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin001101111111] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001101111111] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001101111111] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001101111111] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001101111111] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001101111111] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001101111111] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001101111111] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001101111111] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001101111111] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001101111111] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001101111111] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001101111111] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001101111111] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001101111111] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001101111111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001101111111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001101111111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001101111111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001110000000] & Y[0bin001110101111] = 0bin0); +ASSERT (Y[0bin001110000000] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin001110000000] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin001110000000] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin001110000000] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001110000000] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001110000000] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001110000000] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001110000000] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001110000000] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001110000000] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001110000000] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001110000000] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001110000000] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001110000000] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001110000000] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001110000000] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001110000000] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001110000000] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001110000000] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001110000000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001110000000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001110000000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001110000000] & Y[0bin001111011101] = 0bin0); +ASSERT (Y[0bin001110000000] & Y[0bin001111011110] = 0bin0); +ASSERT (Y[0bin001110000000] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin001110000000] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin001110000000] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin001110000000] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001110000000] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001110000000] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001110000000] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001110000000] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001110000000] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001110000000] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001110000000] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001110000000] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001110000000] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001110000000] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001110000000] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001110000000] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001110000000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001110000000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001110000000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001110000000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001110000000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin001110110000] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin001111011110] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin010000001100] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin010000001101] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001110000001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin001110110001] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin010000001101] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin010000111011] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin010000111100] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001110000010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin001110110010] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010000111100] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010001101010] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010001101011] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001110000011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin001110110011] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010001101011] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010010011001] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010010011010] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001110000100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin001110110100] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010010011010] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010011001000] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010011001001] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001110000101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin001110110101] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010011001001] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010011110111] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001110000110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin001110110110] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010100100110] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001110000111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin001110110111] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010101010101] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001110001000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin001110111000] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010110000100] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001110001001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin001110111001] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010110110011] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001110001010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin001110111010] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010111100010] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001110001011] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin001110111011] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin011000010001] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001110001100] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin001110111100] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin011001000000] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001110001101] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin001110111101] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin011001101111] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001110001110] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin001110111110] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin011010011110] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001110001111] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin001110111111] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin011011001101] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001110010000] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin001111000000] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin011011111100] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001110010001] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin001111000001] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin011100101011] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin001110010010] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin001111000010] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin011101011010] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin001110010011] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin001111000011] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin011110001001] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin001110010100] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin001110010101] & Y[0bin001111000100] = 0bin0); +ASSERT (Y[0bin001110010101] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001110010101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001110010101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001110010101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001110010101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001110010101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001110010101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001110010101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001110010101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001110010101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001110010101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001110010101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001110010101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001110010101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001110010101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001110010101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001110010101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001110010101] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001110010101] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001110010101] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001110010101] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001110010101] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001110010101] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001110010101] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001110010101] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001110010101] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001110010101] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001110010101] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001110010101] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001110010101] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001110010101] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001110010101] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001110010101] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001110010101] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001110010101] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001110010101] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001110010101] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001110010101] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin001110010101] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001110010101] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin001110010101] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin001110010101] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin001110010101] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin001110010101] & Y[0bin011110111000] = 0bin0); +ASSERT (Y[0bin001110010101] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin001110010110] & Y[0bin001111000101] = 0bin0); +ASSERT (Y[0bin001110010110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001110010110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001110010110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001110010110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001110010110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001110010110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001110010110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001110010110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001110010110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001110010110] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001110010110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001110010110] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001110010110] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001110010110] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001110010110] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001110010110] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001110010110] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001110010110] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001110010110] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001110010110] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin001110010110] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin001110010110] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin001110010110] & Y[0bin011111100111] = 0bin0); +ASSERT (Y[0bin001110101110] & Y[0bin001111011101] = 0bin0); +ASSERT (Y[0bin001110101110] & Y[0bin001111011110] = 0bin0); +ASSERT (Y[0bin001110101110] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin001110101110] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin001110101110] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin001110101110] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001110101110] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001110101110] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001110101110] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001110101110] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001110101110] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001110101110] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001110101110] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001110101110] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001110101110] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001110101110] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001110101110] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001110101110] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001110101110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001110101110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001110101110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001110101110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001110101110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001110101111] & Y[0bin001111011110] = 0bin0); +ASSERT (Y[0bin001110101111] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin001110101111] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin001110101111] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin001110101111] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001110101111] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001110101111] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001110101111] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001110101111] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001110101111] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001110101111] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001110101111] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001110101111] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001110101111] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001110101111] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001110101111] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001110101111] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001110101111] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001110101111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001110101111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001110101111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001110101111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001110101111] & Y[0bin010000001100] = 0bin0); +ASSERT (Y[0bin001110101111] & Y[0bin010000001101] = 0bin0); +ASSERT (Y[0bin001110101111] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin001110101111] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin001110101111] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001110101111] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001110101111] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001110101111] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001110101111] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001110101111] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001110101111] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001110101111] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001110101111] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001110101111] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001110101111] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001110101111] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001110101111] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001110101111] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001110101111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001110101111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001110101111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001110101111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin001111011111] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin010000001101] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin010000111011] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin010000111100] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001110110000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin001111100000] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010000111100] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010001101010] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010001101011] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001110110001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin001111100001] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010001101011] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010010011001] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010010011010] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001110110010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin001111100010] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010010011010] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010011001000] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010011001001] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001110110011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin001111100011] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010011001001] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010011110111] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001110110100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin001111100100] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010100100110] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001110110101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin001111100101] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010101010101] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001110110110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin001111100110] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010110000100] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001110110111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin001111100111] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010110110011] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001110111000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin001111101000] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010111100010] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001110111001] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin001111101001] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin011000010001] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001110111010] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin001111101010] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin011001000000] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001110111011] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin001111101011] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin011001101111] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001110111100] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin001111101100] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin011010011110] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001110111101] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin001111101101] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin011011001101] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001110111110] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin001111101110] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin011011111100] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001110111111] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin001111101111] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin011100101011] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin001111000000] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin001111110000] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin011101011010] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin001111000001] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin001111110001] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin011110001001] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin001111000010] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin001111000011] & Y[0bin001111110010] = 0bin0); +ASSERT (Y[0bin001111000011] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001111000011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001111000011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001111000011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001111000011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001111000011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001111000011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001111000011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001111000011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001111000011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001111000011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001111000011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001111000011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001111000011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001111000011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001111000011] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001111000011] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001111000011] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001111000011] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001111000011] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001111000011] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001111000011] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001111000011] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001111000011] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001111000011] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001111000011] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001111000011] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001111000011] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001111000011] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001111000011] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001111000011] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001111000011] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001111000011] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001111000011] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001111000011] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001111000011] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin001111000011] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001111000011] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin001111000011] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin001111000011] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin001111000011] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin001111000011] & Y[0bin011110111000] = 0bin0); +ASSERT (Y[0bin001111000011] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin001111000100] & Y[0bin001111110011] = 0bin0); +ASSERT (Y[0bin001111000100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001111000100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001111000100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001111000100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001111000100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001111000100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001111000100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001111000100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001111000100] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001111000100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001111000100] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001111000100] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001111000100] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001111000100] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001111000100] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001111000100] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001111000100] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001111000100] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001111000100] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin001111000100] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin001111000100] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin001111000100] & Y[0bin011111100111] = 0bin0); +ASSERT (Y[0bin001111011101] & Y[0bin010000001100] = 0bin0); +ASSERT (Y[0bin001111011101] & Y[0bin010000001101] = 0bin0); +ASSERT (Y[0bin001111011101] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin001111011101] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin001111011101] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001111011101] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001111011101] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001111011101] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001111011101] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001111011101] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001111011101] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001111011101] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001111011101] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001111011101] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001111011101] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001111011101] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001111011101] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001111011101] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001111011101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001111011101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001111011101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001111011101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001111011110] & Y[0bin010000001101] = 0bin0); +ASSERT (Y[0bin001111011110] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin001111011110] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin001111011110] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001111011110] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001111011110] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001111011110] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001111011110] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001111011110] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001111011110] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001111011110] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001111011110] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001111011110] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001111011110] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001111011110] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001111011110] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001111011110] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001111011110] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001111011110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001111011110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001111011110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001111011110] & Y[0bin010000111011] = 0bin0); +ASSERT (Y[0bin001111011110] & Y[0bin010000111100] = 0bin0); +ASSERT (Y[0bin001111011110] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin001111011110] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin001111011110] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001111011110] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001111011110] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001111011110] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001111011110] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001111011110] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001111011110] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001111011110] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001111011110] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001111011110] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001111011110] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001111011110] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001111011110] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001111011110] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001111011110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001111011110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001111011110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010000001110] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010000111100] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010001101010] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010001101011] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001111011111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010000001111] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010001101011] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010010011001] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010010011010] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001111100000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010000010000] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010010011010] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010011001000] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010011001001] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001111100001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010000010001] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010011001001] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010011110111] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001111100010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010000010010] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010100100110] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001111100011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010000010011] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010101010101] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001111100100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010000010100] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010110000100] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001111100101] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010000010101] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010110110011] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001111100110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010000010110] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010111100010] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001111100111] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010000010111] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin011000010001] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001111101000] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010000011000] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin011001000000] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001111101001] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010000011001] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin011001101111] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001111101010] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010000011010] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin011010011110] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001111101011] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010000011011] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin011011001101] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001111101100] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010000011100] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin011011111100] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001111101101] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010000011101] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin011100101011] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin001111101110] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin010000011110] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin011101011010] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin001111101111] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin010000011111] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin011110001001] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin001111110000] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin001111110001] & Y[0bin010000100000] = 0bin0); +ASSERT (Y[0bin001111110001] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001111110001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin001111110001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001111110001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin001111110001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001111110001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin001111110001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001111110001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin001111110001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001111110001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin001111110001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001111110001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin001111110001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001111110001] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin001111110001] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001111110001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin001111110001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001111110001] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin001111110001] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001111110001] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin001111110001] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001111110001] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin001111110001] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001111110001] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin001111110001] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001111110001] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin001111110001] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001111110001] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin001111110001] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001111110001] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin001111110001] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001111110001] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin001111110001] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001111110001] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin001111110001] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001111110001] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin001111110001] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin001111110001] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin001111110001] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin001111110001] & Y[0bin011110111000] = 0bin0); +ASSERT (Y[0bin001111110001] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin001111110010] & Y[0bin010000100001] = 0bin0); +ASSERT (Y[0bin001111110010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin001111110010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin001111110010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin001111110010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin001111110010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin001111110010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin001111110010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin001111110010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin001111110010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin001111110010] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin001111110010] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin001111110010] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin001111110010] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin001111110010] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin001111110010] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin001111110010] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin001111110010] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin001111110010] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin001111110010] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin001111110010] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin001111110010] & Y[0bin011111100111] = 0bin0); +ASSERT (Y[0bin010000001100] & Y[0bin010000111011] = 0bin0); +ASSERT (Y[0bin010000001100] & Y[0bin010000111100] = 0bin0); +ASSERT (Y[0bin010000001100] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin010000001100] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin010000001100] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin010000001100] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin010000001100] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin010000001100] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin010000001100] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin010000001100] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin010000001100] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin010000001100] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin010000001100] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin010000001100] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin010000001100] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin010000001100] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin010000001100] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin010000001100] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin010000001100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin010000001100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin010000001100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin010000001101] & Y[0bin010000111100] = 0bin0); +ASSERT (Y[0bin010000001101] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin010000001101] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin010000001101] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin010000001101] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin010000001101] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin010000001101] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin010000001101] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin010000001101] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin010000001101] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin010000001101] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin010000001101] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin010000001101] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin010000001101] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin010000001101] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin010000001101] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin010000001101] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin010000001101] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin010000001101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin010000001101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin010000001101] & Y[0bin010001101010] = 0bin0); +ASSERT (Y[0bin010000001101] & Y[0bin010001101011] = 0bin0); +ASSERT (Y[0bin010000001101] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin010000001101] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin010000001101] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin010000001101] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin010000001101] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin010000001101] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin010000001101] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin010000001101] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin010000001101] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin010000001101] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin010000001101] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin010000001101] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin010000001101] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin010000001101] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin010000001101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin010000001101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin010000001101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin010000001101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010000111101] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010001101011] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010010011001] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010010011010] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010000001110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010000111110] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010010011010] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010011001000] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010011001001] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010000001111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010000111111] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010011001001] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010011110111] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010000010000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010001000000] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010100100110] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010000010001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010001000001] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010101010101] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010000010010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010001000010] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010110000100] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010000010011] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010001000011] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010110110011] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010000010100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010001000100] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010111100010] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010000010101] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010001000101] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin011000010001] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010000010110] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010001000110] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin011001000000] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010000010111] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010001000111] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin011001101111] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010000011000] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010001001000] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin011010011110] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010000011001] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010001001001] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin011011001101] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010000011010] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010001001010] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin011011111100] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010000011011] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin010001001011] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin011100101011] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin010000011100] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin010001001100] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin011101011010] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin010000011101] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin010001001101] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin011110001001] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin010000011110] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin010000011111] & Y[0bin010001001110] = 0bin0); +ASSERT (Y[0bin010000011111] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin010000011111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin010000011111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin010000011111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010000011111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010000011111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010000011111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010000011111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010000011111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010000011111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010000011111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010000011111] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010000011111] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010000011111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010000011111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010000011111] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010000011111] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010000011111] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010000011111] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010000011111] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010000011111] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010000011111] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010000011111] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010000011111] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010000011111] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010000011111] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010000011111] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010000011111] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010000011111] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010000011111] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010000011111] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010000011111] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin010000011111] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010000011111] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin010000011111] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin010000011111] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin010000011111] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin010000011111] & Y[0bin011110111000] = 0bin0); +ASSERT (Y[0bin010000011111] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin010000100000] & Y[0bin010001001111] = 0bin0); +ASSERT (Y[0bin010000100000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin010000100000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010000100000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010000100000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010000100000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010000100000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010000100000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010000100000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010000100000] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010000100000] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010000100000] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010000100000] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010000100000] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010000100000] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010000100000] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010000100000] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010000100000] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin010000100000] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin010000100000] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin010000100000] & Y[0bin011111100111] = 0bin0); +ASSERT (Y[0bin010000111011] & Y[0bin010001101010] = 0bin0); +ASSERT (Y[0bin010000111011] & Y[0bin010001101011] = 0bin0); +ASSERT (Y[0bin010000111011] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin010000111011] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin010000111011] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin010000111011] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin010000111011] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin010000111011] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin010000111011] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin010000111011] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin010000111011] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin010000111011] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin010000111011] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin010000111011] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin010000111011] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin010000111011] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin010000111011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin010000111011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin010000111011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin010000111011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin010000111100] & Y[0bin010001101011] = 0bin0); +ASSERT (Y[0bin010000111100] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin010000111100] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin010000111100] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin010000111100] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin010000111100] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin010000111100] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin010000111100] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin010000111100] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin010000111100] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin010000111100] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin010000111100] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin010000111100] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin010000111100] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin010000111100] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin010000111100] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin010000111100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin010000111100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin010000111100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin010000111100] & Y[0bin010010011001] = 0bin0); +ASSERT (Y[0bin010000111100] & Y[0bin010010011010] = 0bin0); +ASSERT (Y[0bin010000111100] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin010000111100] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin010000111100] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin010000111100] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin010000111100] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin010000111100] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin010000111100] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin010000111100] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin010000111100] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin010000111100] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin010000111100] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin010000111100] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin010000111100] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin010000111100] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin010000111100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin010000111100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010000111100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010001101100] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010010011010] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010011001000] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010011001001] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010000111101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010001101101] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010011001001] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010011110111] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010000111110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010001101110] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010100100110] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010000111111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010001101111] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010101010101] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010001000000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010001110000] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010110000100] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010001000001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010001110001] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010110110011] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010001000010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010001110010] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010111100010] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010001000011] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010001110011] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin011000010001] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010001000100] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010001110100] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin011001000000] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010001000101] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010001110101] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin011001101111] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010001000110] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010001110110] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin011010011110] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010001000111] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010001110111] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin011011001101] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010001001000] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010001111000] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin011011111100] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010001001001] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin010001111001] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin011100101011] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin010001001010] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin010001111010] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin011101011010] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin010001001011] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin010001111011] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin011110001001] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin010001001100] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin010001001101] & Y[0bin010001111100] = 0bin0); +ASSERT (Y[0bin010001001101] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin010001001101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010001001101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010001001101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010001001101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010001001101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010001001101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010001001101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010001001101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010001001101] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010001001101] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010001001101] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010001001101] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010001001101] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010001001101] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010001001101] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010001001101] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010001001101] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010001001101] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010001001101] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010001001101] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010001001101] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010001001101] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010001001101] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010001001101] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010001001101] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010001001101] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010001001101] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010001001101] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010001001101] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin010001001101] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010001001101] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin010001001101] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin010001001101] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin010001001101] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin010001001101] & Y[0bin011110111000] = 0bin0); +ASSERT (Y[0bin010001001101] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin010001001110] & Y[0bin010001111101] = 0bin0); +ASSERT (Y[0bin010001001110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010001001110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010001001110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010001001110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010001001110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010001001110] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010001001110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010001001110] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010001001110] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010001001110] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010001001110] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010001001110] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010001001110] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010001001110] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010001001110] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010001001110] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin010001001110] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin010001001110] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin010001001110] & Y[0bin011111100111] = 0bin0); +ASSERT (Y[0bin010001101010] & Y[0bin010010011001] = 0bin0); +ASSERT (Y[0bin010001101010] & Y[0bin010010011010] = 0bin0); +ASSERT (Y[0bin010001101010] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin010001101010] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin010001101010] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin010001101010] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin010001101010] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin010001101010] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin010001101010] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin010001101010] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin010001101010] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin010001101010] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin010001101010] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin010001101010] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin010001101010] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin010001101010] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin010001101010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin010001101010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010001101010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010001101011] & Y[0bin010010011010] = 0bin0); +ASSERT (Y[0bin010001101011] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin010001101011] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin010001101011] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin010001101011] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin010001101011] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin010001101011] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin010001101011] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin010001101011] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin010001101011] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin010001101011] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin010001101011] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin010001101011] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin010001101011] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin010001101011] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin010001101011] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin010001101011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010001101011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010001101011] & Y[0bin010011001000] = 0bin0); +ASSERT (Y[0bin010001101011] & Y[0bin010011001001] = 0bin0); +ASSERT (Y[0bin010001101011] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin010001101011] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin010001101011] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin010001101011] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin010001101011] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin010001101011] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin010001101011] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin010001101011] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin010001101011] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin010001101011] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin010001101011] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin010001101011] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010001101011] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010001101011] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010001101011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010001101011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010001101100] & Y[0bin010010011011] = 0bin0); +ASSERT (Y[0bin010001101100] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin010001101100] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin010001101100] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin010001101100] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin010001101100] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin010001101100] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin010001101100] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin010001101100] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin010001101100] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin010001101100] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin010001101100] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin010001101100] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin010001101100] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin010001101100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin010001101100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010001101100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010001101100] & Y[0bin010011001001] = 0bin0); +ASSERT (Y[0bin010001101100] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin010001101100] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin010001101100] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin010001101100] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin010001101100] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin010001101100] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin010001101100] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin010001101100] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin010001101100] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin010001101100] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin010001101100] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin010001101100] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010001101100] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010001101100] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010001101100] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010001101100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010001101100] & Y[0bin010011110111] = 0bin0); +ASSERT (Y[0bin010001101100] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin010001101100] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin010001101100] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin010001101100] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin010001101100] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin010001101100] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin010001101100] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin010001101100] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin010001101100] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin010001101100] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010001101100] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010001101100] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010001101100] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010001101100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010001101100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010001101100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010010011100] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010100100110] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010001101101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010010011101] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010101010101] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010001101110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010010011110] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010110000100] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010001101111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010010011111] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010110110011] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010001110000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010010100000] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010111100010] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010001110001] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010010100001] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin011000010001] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010001110010] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010010100010] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin011001000000] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010001110011] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010010100011] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin011001101111] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010001110100] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010010100100] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin011010011110] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010001110101] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010010100101] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin011011001101] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010001110110] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin010010100110] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin011011111100] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010001110111] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin010010100111] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin011100101011] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin010001111000] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin010010101000] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin011101011010] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin010001111001] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin010001111010] & Y[0bin010010101001] = 0bin0); +ASSERT (Y[0bin010001111010] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010001111010] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010001111010] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010001111010] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010001111010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010001111010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010001111010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010001111010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010001111010] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010001111010] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010001111010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010001111010] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010001111010] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010001111010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010001111010] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010001111010] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010001111010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010001111010] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010001111010] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010001111010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010001111010] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010001111010] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010001111010] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010001111010] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010001111010] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010001111010] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010001111010] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010001111010] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010001111010] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010001111010] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010001111010] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010001111010] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010001111010] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010001111010] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010001111010] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010001111010] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010001111010] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010001111010] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010001111010] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin010001111010] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010001111010] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010001111010] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin010001111010] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin010001111010] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010001111010] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin010001111010] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin010001111010] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin010001111010] & Y[0bin011110001001] = 0bin0); +ASSERT (Y[0bin010001111010] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin010001111010] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin010001111011] & Y[0bin010010101010] = 0bin0); +ASSERT (Y[0bin010001111011] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010001111011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010001111011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010001111011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010001111011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010001111011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010001111011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010001111011] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010001111011] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010001111011] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010001111011] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010001111011] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010001111011] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010001111011] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010001111011] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010001111011] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010001111011] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010001111011] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010001111011] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010001111011] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010001111011] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010001111011] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010001111011] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010001111011] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010001111011] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010001111011] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010001111011] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010001111011] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin010001111011] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010001111011] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin010001111011] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin010001111011] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin010001111011] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin010001111011] & Y[0bin011110111000] = 0bin0); +ASSERT (Y[0bin010001111011] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin010001111100] & Y[0bin010010101011] = 0bin0); +ASSERT (Y[0bin010001111100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010001111100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010001111100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010001111100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010001111100] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010001111100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010001111100] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010001111100] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010001111100] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010001111100] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010001111100] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010001111100] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010001111100] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010001111100] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010001111100] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin010001111100] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin010001111100] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin010001111100] & Y[0bin011111100111] = 0bin0); +ASSERT (Y[0bin010010011001] & Y[0bin010011001000] = 0bin0); +ASSERT (Y[0bin010010011001] & Y[0bin010011001001] = 0bin0); +ASSERT (Y[0bin010010011001] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin010010011001] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin010010011001] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin010010011001] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin010010011001] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin010010011001] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin010010011001] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin010010011001] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin010010011001] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin010010011001] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin010010011001] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin010010011001] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010010011001] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010010011001] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010010011001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010010011001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010010011010] & Y[0bin010011001001] = 0bin0); +ASSERT (Y[0bin010010011010] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin010010011010] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin010010011010] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin010010011010] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin010010011010] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin010010011010] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin010010011010] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin010010011010] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin010010011010] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin010010011010] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin010010011010] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin010010011010] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010010011010] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010010011010] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010010011010] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010010011010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010010011010] & Y[0bin010011110111] = 0bin0); +ASSERT (Y[0bin010010011010] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin010010011010] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin010010011010] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin010010011010] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin010010011010] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin010010011010] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin010010011010] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin010010011010] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin010010011010] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin010010011010] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010010011010] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010010011010] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010010011010] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010010011010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010010011010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010010011010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010010011011] & Y[0bin010011001010] = 0bin0); +ASSERT (Y[0bin010010011011] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin010010011011] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin010010011011] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin010010011011] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin010010011011] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin010010011011] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin010010011011] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin010010011011] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin010010011011] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin010010011011] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin010010011011] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010010011011] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010010011011] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010010011011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010010011011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010010011011] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin010010011011] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin010010011011] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin010010011011] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin010010011011] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin010010011011] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin010010011011] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin010010011011] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin010010011011] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin010010011011] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010010011011] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010010011011] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010010011011] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010010011011] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010010011011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010010011011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010010011011] & Y[0bin010100100110] = 0bin0); +ASSERT (Y[0bin010010011011] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin010010011011] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin010010011011] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin010010011011] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin010010011011] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin010010011011] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin010010011011] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin010010011011] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010010011011] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010010011011] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010010011011] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010010011011] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010010011011] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010010011011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010010011011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010011001011] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010101010101] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010010011100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010011001100] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010110000100] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010010011101] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010011001101] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010110110011] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010010011110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010011001110] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010111100010] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010010011111] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010011001111] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin011000010001] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010010100000] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010011010000] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin011001000000] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010010100001] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010011010001] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin011001101111] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010010100010] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010011010010] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin011010011110] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010010100011] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin010011010011] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin011011001101] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010010100100] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin010011010100] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin011011111100] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010010100101] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin010011010101] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin011100101011] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin010010100110] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin010011010110] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin011101011010] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin010010100111] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin010010101000] & Y[0bin010011010111] = 0bin0); +ASSERT (Y[0bin010010101000] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010010101000] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010010101000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010010101000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010010101000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010010101000] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010010101000] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010010101000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010010101000] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010010101000] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010010101000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010010101000] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010010101000] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010010101000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010010101000] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010010101000] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010010101000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010010101000] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010010101000] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010010101000] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010010101000] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010010101000] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010010101000] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010010101000] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010010101000] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010010101000] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010010101000] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010010101000] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010010101000] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010010101000] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010010101000] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010010101000] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010010101000] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010010101000] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010010101000] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010010101000] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin010010101000] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010010101000] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010010101000] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin010010101000] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin010010101000] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010010101000] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin010010101000] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin010010101000] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin010010101000] & Y[0bin011110001001] = 0bin0); +ASSERT (Y[0bin010010101000] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin010010101000] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin010010101001] & Y[0bin010011011000] = 0bin0); +ASSERT (Y[0bin010010101001] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010010101001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010010101001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010010101001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010010101001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010010101001] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010010101001] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010010101001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010010101001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010010101001] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010010101001] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010010101001] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010010101001] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010010101001] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010010101001] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010010101001] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010010101001] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010010101001] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010010101001] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010010101001] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010010101001] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010010101001] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010010101001] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010010101001] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010010101001] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010010101001] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin010010101001] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010010101001] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin010010101001] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin010010101001] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin010010101001] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin010010101001] & Y[0bin011110111000] = 0bin0); +ASSERT (Y[0bin010010101001] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin010010101010] & Y[0bin010011011001] = 0bin0); +ASSERT (Y[0bin010010101010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010010101010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010010101010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010010101010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010010101010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010010101010] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010010101010] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010010101010] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010010101010] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010010101010] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010010101010] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010010101010] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010010101010] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010010101010] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin010010101010] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin010010101010] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin010010101010] & Y[0bin011111100111] = 0bin0); +ASSERT (Y[0bin010011001000] & Y[0bin010011110111] = 0bin0); +ASSERT (Y[0bin010011001000] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin010011001000] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin010011001000] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin010011001000] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin010011001000] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin010011001000] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin010011001000] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin010011001000] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin010011001000] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin010011001000] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010011001000] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010011001000] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010011001000] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010011001000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010011001000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010011001000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010011001001] & Y[0bin010011111000] = 0bin0); +ASSERT (Y[0bin010011001001] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin010011001001] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin010011001001] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin010011001001] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin010011001001] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin010011001001] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin010011001001] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin010011001001] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin010011001001] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010011001001] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010011001001] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010011001001] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010011001001] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010011001001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010011001001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010011001001] & Y[0bin010100100110] = 0bin0); +ASSERT (Y[0bin010011001001] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin010011001001] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin010011001001] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin010011001001] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin010011001001] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin010011001001] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin010011001001] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin010011001001] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010011001001] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010011001001] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010011001001] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010011001001] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010011001001] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010011001001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010011001001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010011001010] & Y[0bin010011111001] = 0bin0); +ASSERT (Y[0bin010011001010] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin010011001010] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin010011001010] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin010011001010] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin010011001010] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin010011001010] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin010011001010] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin010011001010] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010011001010] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010011001010] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010011001010] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010011001010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010011001010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010011001010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010011001010] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin010011001010] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin010011001010] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin010011001010] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin010011001010] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin010011001010] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin010011001010] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin010011001010] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010011001010] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010011001010] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010011001010] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010011001010] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010011001010] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010011001010] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010011001010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010011001010] & Y[0bin010101010101] = 0bin0); +ASSERT (Y[0bin010011001010] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin010011001010] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin010011001010] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin010011001010] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin010011001010] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin010011001010] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin010011001010] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010011001010] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010011001010] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010011001010] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010011001010] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010011001010] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010011001010] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010011001010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010011111010] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010110000100] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010011001011] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010011111011] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010110110011] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010011001100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010011111100] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010111100010] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010011001101] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010011111101] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin011000010001] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010011001110] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010011111110] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin011001000000] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010011001111] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010011111111] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin011001101111] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010011010000] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin010100000000] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin011010011110] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010011010001] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin010100000001] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin011011001101] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010011010010] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin010100000010] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin011011111100] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010011010011] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin010100000011] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin011100101011] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin010011010100] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin010100000100] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin011101011010] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin010011010101] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin010011010110] & Y[0bin010100000101] = 0bin0); +ASSERT (Y[0bin010011010110] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010011010110] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010011010110] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010011010110] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010011010110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010011010110] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010011010110] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010011010110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010011010110] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010011010110] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010011010110] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010011010110] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010011010110] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010011010110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010011010110] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010011010110] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010011010110] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010011010110] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010011010110] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010011010110] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010011010110] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010011010110] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010011010110] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010011010110] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010011010110] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010011010110] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010011010110] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010011010110] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010011010110] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010011010110] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010011010110] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010011010110] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010011010110] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin010011010110] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010011010110] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010011010110] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin010011010110] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin010011010110] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010011010110] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin010011010110] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin010011010110] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin010011010110] & Y[0bin011110001001] = 0bin0); +ASSERT (Y[0bin010011010110] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin010011010110] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin010011010111] & Y[0bin010100000110] = 0bin0); +ASSERT (Y[0bin010011010111] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010011010111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010011010111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010011010111] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010011010111] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010011010111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010011010111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010011010111] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010011010111] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010011010111] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010011010111] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010011010111] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010011010111] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010011010111] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010011010111] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010011010111] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010011010111] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010011010111] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010011010111] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010011010111] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010011010111] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010011010111] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010011010111] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010011010111] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin010011010111] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010011010111] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin010011010111] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin010011010111] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin010011010111] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin010011010111] & Y[0bin011110111000] = 0bin0); +ASSERT (Y[0bin010011010111] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin010011011000] & Y[0bin010100000111] = 0bin0); +ASSERT (Y[0bin010011011000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010011011000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010011011000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010011011000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010011011000] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010011011000] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010011011000] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010011011000] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010011011000] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010011011000] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010011011000] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010011011000] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010011011000] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin010011011000] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin010011011000] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin010011011000] & Y[0bin011111100111] = 0bin0); +ASSERT (Y[0bin010011110111] & Y[0bin010100100110] = 0bin0); +ASSERT (Y[0bin010011110111] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin010011110111] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin010011110111] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin010011110111] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin010011110111] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin010011110111] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin010011110111] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin010011110111] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010011110111] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010011110111] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010011110111] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010011110111] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010011110111] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010011110111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010011110111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010011111000] & Y[0bin010100100111] = 0bin0); +ASSERT (Y[0bin010011111000] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin010011111000] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin010011111000] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin010011111000] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin010011111000] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin010011111000] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin010011111000] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010011111000] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010011111000] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010011111000] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010011111000] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010011111000] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010011111000] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010011111000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010011111000] & Y[0bin010101010101] = 0bin0); +ASSERT (Y[0bin010011111000] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin010011111000] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin010011111000] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin010011111000] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin010011111000] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin010011111000] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin010011111000] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010011111000] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010011111000] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010011111000] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010011111000] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010011111000] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010011111000] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010011111000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010011111001] & Y[0bin010100101000] = 0bin0); +ASSERT (Y[0bin010011111001] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin010011111001] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin010011111001] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin010011111001] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin010011111001] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin010011111001] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010011111001] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010011111001] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010011111001] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010011111001] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010011111001] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010011111001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010011111001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010011111001] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin010011111001] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin010011111001] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin010011111001] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin010011111001] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin010011111001] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin010011111001] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010011111001] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010011111001] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010011111001] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010011111001] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010011111001] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010011111001] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010011111001] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010011111001] & Y[0bin010110000100] = 0bin0); +ASSERT (Y[0bin010011111001] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin010011111001] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin010011111001] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin010011111001] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin010011111001] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin010011111001] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010011111001] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010011111001] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010011111001] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010011111001] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010011111001] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010011111001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010011111001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010011111010] & Y[0bin010100101001] = 0bin0); +ASSERT (Y[0bin010011111010] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin010011111010] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin010011111010] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin010011111010] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin010011111010] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010011111010] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010011111010] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010011111010] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010011111010] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010011111010] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010011111010] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010011111010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010011111010] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin010011111010] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin010011111010] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin010011111010] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin010011111010] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin010011111010] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010011111010] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010011111010] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010011111010] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010011111010] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010011111010] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010011111010] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010011111010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010011111010] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin010011111010] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin010011111010] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin010011111010] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin010011111010] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin010011111010] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010011111010] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010011111010] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010011111010] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010011111010] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010011111010] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010011111010] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010011111010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010011111010] & Y[0bin010110110011] = 0bin0); +ASSERT (Y[0bin010011111010] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin010011111010] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin010011111010] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin010011111010] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin010011111010] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010011111010] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010011111010] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010011111010] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010011111010] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010011111010] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010011111010] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010011111010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010100101010] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010111100010] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010011111011] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010100101011] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin011000010001] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010011111100] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin010100101100] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin011001000000] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010011111101] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin010100101101] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin011001101111] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010011111110] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin010100101110] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin011010011110] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010011111111] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin010100101111] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin011011001101] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010100000000] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin010100110000] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin011011111100] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010100000001] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin010100110001] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin011100101011] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin010100000010] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010100000011] & Y[0bin010100110010] = 0bin0); +ASSERT (Y[0bin010100000011] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010100000011] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010100000011] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010100000011] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010100000011] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010100000011] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010100000011] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010100000011] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010100000011] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010100000011] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010100000011] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010100000011] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010100000011] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010100000011] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010100000011] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010100000011] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010100000011] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010100000011] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010100000011] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010100000011] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010100000011] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010100000011] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010100000011] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010100000011] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010100000011] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010100000011] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010100000011] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010100000011] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010100000011] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010100000011] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010100000011] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010100000011] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010100000011] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010100000011] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010100000011] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010100000011] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin010100000011] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010100000011] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010100000011] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010100000011] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin010100000011] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin010100000011] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010100000011] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010100000011] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin010100000011] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin010100000011] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin010100000011] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010100000011] & Y[0bin011101011010] = 0bin0); +ASSERT (Y[0bin010100000011] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin010100000011] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin010100000011] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin010100000100] & Y[0bin010100110011] = 0bin0); +ASSERT (Y[0bin010100000100] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010100000100] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010100000100] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010100000100] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010100000100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010100000100] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010100000100] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010100000100] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010100000100] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010100000100] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010100000100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010100000100] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010100000100] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010100000100] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010100000100] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010100000100] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010100000100] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010100000100] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010100000100] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010100000100] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010100000100] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010100000100] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010100000100] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010100000100] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010100000100] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010100000100] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010100000100] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010100000100] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010100000100] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010100000100] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin010100000100] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010100000100] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010100000100] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin010100000100] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin010100000100] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010100000100] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin010100000100] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin010100000100] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin010100000100] & Y[0bin011110001001] = 0bin0); +ASSERT (Y[0bin010100000100] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin010100000100] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin010100000101] & Y[0bin010100110100] = 0bin0); +ASSERT (Y[0bin010100000101] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010100000101] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010100000101] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010100000101] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010100000101] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010100000101] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010100000101] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010100000101] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010100000101] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010100000101] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010100000101] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010100000101] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010100000101] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010100000101] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010100000101] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010100000101] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010100000101] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010100000101] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010100000101] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010100000101] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010100000101] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010100000101] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin010100000101] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010100000101] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin010100000101] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin010100000101] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin010100000101] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin010100000101] & Y[0bin011110111000] = 0bin0); +ASSERT (Y[0bin010100000101] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin010100000110] & Y[0bin010100110101] = 0bin0); +ASSERT (Y[0bin010100000110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010100000110] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010100000110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010100000110] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010100000110] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010100000110] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010100000110] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010100000110] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010100000110] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010100000110] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010100000110] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010100000110] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin010100000110] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin010100000110] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin010100000110] & Y[0bin011111100111] = 0bin0); +ASSERT (Y[0bin010100100110] & Y[0bin010101010101] = 0bin0); +ASSERT (Y[0bin010100100110] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin010100100110] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin010100100110] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin010100100110] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin010100100110] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin010100100110] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin010100100110] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010100100110] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010100100110] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010100100110] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010100100110] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010100100110] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010100100110] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010100100110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010100100111] & Y[0bin010101010110] = 0bin0); +ASSERT (Y[0bin010100100111] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin010100100111] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin010100100111] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin010100100111] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin010100100111] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin010100100111] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010100100111] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010100100111] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010100100111] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010100100111] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010100100111] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010100100111] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010100100111] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010100100111] & Y[0bin010110000100] = 0bin0); +ASSERT (Y[0bin010100100111] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin010100100111] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin010100100111] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin010100100111] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin010100100111] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin010100100111] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010100100111] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010100100111] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010100100111] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010100100111] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010100100111] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010100100111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010100100111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010100101000] & Y[0bin010101010111] = 0bin0); +ASSERT (Y[0bin010100101000] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin010100101000] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin010100101000] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin010100101000] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin010100101000] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010100101000] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010100101000] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010100101000] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010100101000] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010100101000] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010100101000] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010100101000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010100101000] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin010100101000] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin010100101000] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin010100101000] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin010100101000] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin010100101000] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010100101000] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010100101000] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010100101000] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010100101000] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010100101000] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010100101000] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010100101000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010100101000] & Y[0bin010110110011] = 0bin0); +ASSERT (Y[0bin010100101000] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin010100101000] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin010100101000] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin010100101000] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin010100101000] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010100101000] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010100101000] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010100101000] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010100101000] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010100101000] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010100101000] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010100101000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010100101001] & Y[0bin010101011000] = 0bin0); +ASSERT (Y[0bin010100101001] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin010100101001] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin010100101001] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin010100101001] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010100101001] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010100101001] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010100101001] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010100101001] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010100101001] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010100101001] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010100101001] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010100101001] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin010100101001] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin010100101001] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin010100101001] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin010100101001] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010100101001] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010100101001] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010100101001] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010100101001] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010100101001] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010100101001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010100101001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010100101001] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin010100101001] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin010100101001] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin010100101001] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin010100101001] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010100101001] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010100101001] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010100101001] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010100101001] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010100101001] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010100101001] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010100101001] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010100101001] & Y[0bin010111100010] = 0bin0); +ASSERT (Y[0bin010100101001] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin010100101001] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin010100101001] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin010100101001] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin010100101001] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010100101001] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010100101001] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010100101001] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010100101001] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010100101001] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010100101001] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin010101011001] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin011000010001] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010100101010] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin010101011010] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin011001000000] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010100101011] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin010101011011] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin011001101111] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010100101100] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin010101011100] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin011010011110] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010100101101] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin010101011101] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin011011001101] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010100101110] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin010101011110] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin011011111100] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010100101111] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin010101011111] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin011100101011] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin010100110000] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010100110001] & Y[0bin010101100000] = 0bin0); +ASSERT (Y[0bin010100110001] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010100110001] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010100110001] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010100110001] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010100110001] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010100110001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010100110001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010100110001] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010100110001] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010100110001] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010100110001] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010100110001] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010100110001] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010100110001] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010100110001] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010100110001] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010100110001] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010100110001] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010100110001] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010100110001] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010100110001] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010100110001] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010100110001] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010100110001] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010100110001] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010100110001] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010100110001] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010100110001] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010100110001] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010100110001] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010100110001] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010100110001] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin010100110001] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010100110001] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010100110001] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010100110001] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin010100110001] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin010100110001] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010100110001] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010100110001] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin010100110001] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin010100110001] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin010100110001] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010100110001] & Y[0bin011101011010] = 0bin0); +ASSERT (Y[0bin010100110001] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin010100110001] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin010100110001] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin010100110010] & Y[0bin010101100001] = 0bin0); +ASSERT (Y[0bin010100110010] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010100110010] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010100110010] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010100110010] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010100110010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010100110010] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010100110010] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010100110010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010100110010] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010100110010] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010100110010] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010100110010] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010100110010] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010100110010] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010100110010] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010100110010] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010100110010] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010100110010] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010100110010] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010100110010] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010100110010] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010100110010] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010100110010] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010100110010] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010100110010] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010100110010] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010100110010] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin010100110010] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010100110010] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010100110010] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin010100110010] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin010100110010] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010100110010] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin010100110010] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin010100110010] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin010100110010] & Y[0bin011110001001] = 0bin0); +ASSERT (Y[0bin010100110010] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin010100110010] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin010100110011] & Y[0bin010101100010] = 0bin0); +ASSERT (Y[0bin010100110011] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010100110011] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010100110011] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010100110011] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010100110011] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010100110011] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010100110011] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010100110011] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010100110011] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010100110011] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010100110011] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010100110011] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010100110011] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010100110011] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010100110011] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010100110011] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010100110011] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010100110011] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010100110011] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010100110011] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin010100110011] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010100110011] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin010100110011] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin010100110011] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin010100110011] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin010100110011] & Y[0bin011110111000] = 0bin0); +ASSERT (Y[0bin010100110011] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin010100110100] & Y[0bin010101100011] = 0bin0); +ASSERT (Y[0bin010100110100] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010100110100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010100110100] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010100110100] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010100110100] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010100110100] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010100110100] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010100110100] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010100110100] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010100110100] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010100110100] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin010100110100] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin010100110100] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin010100110100] & Y[0bin011111100111] = 0bin0); +ASSERT (Y[0bin010101010101] & Y[0bin010110000100] = 0bin0); +ASSERT (Y[0bin010101010101] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin010101010101] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin010101010101] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin010101010101] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin010101010101] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin010101010101] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010101010101] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010101010101] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010101010101] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010101010101] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010101010101] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010101010101] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010101010101] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010101010110] & Y[0bin010110000101] = 0bin0); +ASSERT (Y[0bin010101010110] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin010101010110] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin010101010110] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin010101010110] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin010101010110] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010101010110] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010101010110] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010101010110] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010101010110] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010101010110] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010101010110] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010101010110] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010101010110] & Y[0bin010110110011] = 0bin0); +ASSERT (Y[0bin010101010110] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin010101010110] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin010101010110] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin010101010110] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin010101010110] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010101010110] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010101010110] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010101010110] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010101010110] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010101010110] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010101010110] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010101010110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010101010111] & Y[0bin010110000110] = 0bin0); +ASSERT (Y[0bin010101010111] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin010101010111] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin010101010111] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin010101010111] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010101010111] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010101010111] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010101010111] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010101010111] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010101010111] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010101010111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010101010111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010101010111] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin010101010111] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin010101010111] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin010101010111] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin010101010111] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010101010111] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010101010111] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010101010111] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010101010111] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010101010111] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010101010111] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010101010111] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010101010111] & Y[0bin010111100010] = 0bin0); +ASSERT (Y[0bin010101010111] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin010101010111] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin010101010111] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin010101010111] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin010101010111] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010101010111] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010101010111] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010101010111] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010101010111] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010101010111] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010101010111] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010101011000] & Y[0bin010110000111] = 0bin0); +ASSERT (Y[0bin010101011000] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin010101011000] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin010101011000] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010101011000] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010101011000] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010101011000] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010101011000] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010101011000] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010101011000] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010101011000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010101011000] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin010101011000] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin010101011000] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin010101011000] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010101011000] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010101011000] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010101011000] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010101011000] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010101011000] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010101011000] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010101011000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010101011000] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin010101011000] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin010101011000] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin010101011000] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin010101011000] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010101011000] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010101011000] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010101011000] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010101011000] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010101011000] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010101011000] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010101011000] & Y[0bin011000010001] = 0bin0); +ASSERT (Y[0bin010101011000] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin010101011000] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin010101011000] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin010101011000] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010101011000] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010101011000] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010101011000] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010101011000] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010101011000] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010101011000] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010101011001] & Y[0bin010110001000] = 0bin0); +ASSERT (Y[0bin010101011001] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin010101011001] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010101011001] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010101011001] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010101011001] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010101011001] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010101011001] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010101011001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010101011001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010101011001] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin010101011001] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin010101011001] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010101011001] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010101011001] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010101011001] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010101011001] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010101011001] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010101011001] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010101011001] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010101011001] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin010101011001] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin010101011001] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin010101011001] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010101011001] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010101011001] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010101011001] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010101011001] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010101011001] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010101011001] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010101011001] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin010101011001] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin010101011001] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin010101011001] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010101011001] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010101011001] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010101011001] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010101011001] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010101011001] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010101011001] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010101011001] & Y[0bin011001000000] = 0bin0); +ASSERT (Y[0bin010101011001] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin010101011001] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin010101011001] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin010101011001] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010101011001] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010101011001] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010101011001] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010101011001] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010101011001] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin010110001001] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin011001101111] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010101011010] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin010110001010] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin011010011110] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010101011011] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin010110001011] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin011011001101] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010101011100] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin010110001100] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin011011111100] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010101011101] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010101011110] & Y[0bin010110001101] = 0bin0); +ASSERT (Y[0bin010101011110] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010101011110] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010101011110] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010101011110] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010101011110] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010101011110] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010101011110] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010101011110] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010101011110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010101011110] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010101011110] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010101011110] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010101011110] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010101011110] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010101011110] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010101011110] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010101011110] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010101011110] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010101011110] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010101011110] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010101011110] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010101011110] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010101011110] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010101011110] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010101011110] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010101011110] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010101011110] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010101011110] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010101011110] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010101011110] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin010101011110] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010101011110] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010101011110] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010101011110] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010101011110] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin010101011110] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin010101011110] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010101011110] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010101011110] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010101011110] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin010101011110] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin010101011110] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin010101011110] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010101011110] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010101011110] & Y[0bin011100101011] = 0bin0); +ASSERT (Y[0bin010101011110] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin010101011110] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin010101011110] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin010101011110] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010101011111] & Y[0bin010110001110] = 0bin0); +ASSERT (Y[0bin010101011111] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010101011111] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010101011111] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010101011111] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010101011111] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010101011111] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010101011111] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010101011111] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010101011111] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010101011111] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010101011111] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010101011111] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010101011111] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010101011111] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010101011111] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010101011111] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010101011111] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010101011111] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010101011111] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010101011111] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010101011111] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010101011111] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010101011111] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010101011111] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010101011111] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010101011111] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010101011111] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010101011111] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin010101011111] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010101011111] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010101011111] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010101011111] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin010101011111] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin010101011111] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010101011111] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010101011111] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin010101011111] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin010101011111] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin010101011111] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010101011111] & Y[0bin011101011010] = 0bin0); +ASSERT (Y[0bin010101011111] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin010101011111] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin010101011111] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin010101100000] & Y[0bin010110001111] = 0bin0); +ASSERT (Y[0bin010101100000] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010101100000] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010101100000] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010101100000] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010101100000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010101100000] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010101100000] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010101100000] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010101100000] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010101100000] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010101100000] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010101100000] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010101100000] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010101100000] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010101100000] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010101100000] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010101100000] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010101100000] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010101100000] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010101100000] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010101100000] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010101100000] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010101100000] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010101100000] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin010101100000] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010101100000] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010101100000] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin010101100000] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin010101100000] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010101100000] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin010101100000] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin010101100000] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin010101100000] & Y[0bin011110001001] = 0bin0); +ASSERT (Y[0bin010101100000] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin010101100000] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin010101100001] & Y[0bin010110010000] = 0bin0); +ASSERT (Y[0bin010101100001] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010101100001] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010101100001] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010101100001] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010101100001] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010101100001] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010101100001] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010101100001] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010101100001] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010101100001] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010101100001] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010101100001] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010101100001] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010101100001] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010101100001] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010101100001] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010101100001] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010101100001] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin010101100001] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010101100001] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin010101100001] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin010101100001] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin010101100001] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin010101100001] & Y[0bin011110111000] = 0bin0); +ASSERT (Y[0bin010101100001] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin010101100010] & Y[0bin010110010001] = 0bin0); +ASSERT (Y[0bin010101100010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010101100010] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010101100010] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010101100010] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010101100010] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010101100010] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010101100010] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010101100010] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010101100010] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010101100010] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin010101100010] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin010101100010] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin010101100010] & Y[0bin011111100111] = 0bin0); +ASSERT (Y[0bin010110000100] & Y[0bin010110110011] = 0bin0); +ASSERT (Y[0bin010110000100] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin010110000100] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin010110000100] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin010110000100] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin010110000100] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010110000100] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010110000100] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010110000100] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010110000100] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010110000100] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010110000100] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010110000100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010110000101] & Y[0bin010110110100] = 0bin0); +ASSERT (Y[0bin010110000101] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin010110000101] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin010110000101] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin010110000101] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010110000101] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010110000101] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010110000101] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010110000101] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010110000101] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010110000101] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010110000101] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010110000101] & Y[0bin010111100010] = 0bin0); +ASSERT (Y[0bin010110000101] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin010110000101] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin010110000101] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin010110000101] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin010110000101] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010110000101] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010110000101] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010110000101] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010110000101] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010110000101] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010110000101] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010110000110] & Y[0bin010110110101] = 0bin0); +ASSERT (Y[0bin010110000110] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin010110000110] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin010110000110] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010110000110] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010110000110] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010110000110] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010110000110] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010110000110] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010110000110] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010110000110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010110000110] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin010110000110] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin010110000110] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin010110000110] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin010110000110] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010110000110] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010110000110] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010110000110] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010110000110] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010110000110] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010110000110] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010110000110] & Y[0bin011000010001] = 0bin0); +ASSERT (Y[0bin010110000110] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin010110000110] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin010110000110] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin010110000110] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010110000110] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010110000110] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010110000110] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010110000110] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010110000110] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010110000110] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010110000111] & Y[0bin010110110110] = 0bin0); +ASSERT (Y[0bin010110000111] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin010110000111] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010110000111] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010110000111] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010110000111] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010110000111] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010110000111] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010110000111] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010110000111] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010110000111] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin010110000111] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin010110000111] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin010110000111] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010110000111] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010110000111] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010110000111] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010110000111] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010110000111] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010110000111] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010110000111] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin010110000111] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin010110000111] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin010110000111] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010110000111] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010110000111] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010110000111] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010110000111] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010110000111] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010110000111] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010110000111] & Y[0bin011001000000] = 0bin0); +ASSERT (Y[0bin010110000111] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin010110000111] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin010110000111] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin010110000111] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010110000111] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010110000111] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010110000111] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010110000111] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010110000111] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010110001000] & Y[0bin010110110111] = 0bin0); +ASSERT (Y[0bin010110001000] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010110001000] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010110001000] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010110001000] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010110001000] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010110001000] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010110001000] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010110001000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010110001000] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin010110001000] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin010110001000] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010110001000] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010110001000] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010110001000] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010110001000] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010110001000] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010110001000] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010110001000] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin010110001000] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin010110001000] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010110001000] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010110001000] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010110001000] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010110001000] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010110001000] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010110001000] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010110001000] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin010110001000] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin010110001000] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin010110001000] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010110001000] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010110001000] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010110001000] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010110001000] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010110001000] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010110001000] & Y[0bin011001101111] = 0bin0); +ASSERT (Y[0bin010110001000] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin010110001000] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin010110001000] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin010110001000] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010110001000] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010110001000] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010110001000] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010110001000] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010110001001] & Y[0bin010110111000] = 0bin0); +ASSERT (Y[0bin010110001001] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010110001001] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010110001001] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010110001001] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010110001001] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010110001001] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010110001001] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010110001001] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin010110001001] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010110001001] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010110001001] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010110001001] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010110001001] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010110001001] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010110001001] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010110001001] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin010110001001] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010110001001] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010110001001] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010110001001] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010110001001] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010110001001] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010110001001] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010110001001] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin010110001001] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin010110001001] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010110001001] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010110001001] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010110001001] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010110001001] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010110001001] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010110001001] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin010110001001] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin010110001001] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin010110001001] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010110001001] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010110001001] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010110001001] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010110001001] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010110001001] & Y[0bin011010011110] = 0bin0); +ASSERT (Y[0bin010110001001] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin010110001001] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin010110001001] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin010110001001] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010110001001] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010110001001] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010110001001] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010110001010] & Y[0bin010110111001] = 0bin0); +ASSERT (Y[0bin010110001010] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010110001010] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010110001010] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010110001010] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010110001010] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010110001010] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010110001010] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010110001010] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010110001010] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010110001010] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010110001010] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010110001010] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010110001010] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010110001010] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010110001010] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010110001010] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010110001010] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010110001010] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010110001010] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010110001010] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010110001010] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin010110001010] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010110001010] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010110001010] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010110001010] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010110001010] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010110001010] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010110001010] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin010110001010] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin010110001010] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010110001010] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010110001010] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010110001010] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010110001010] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010110001010] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin010110001010] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin010110001010] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin010110001010] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010110001010] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010110001010] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010110001010] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010110001010] & Y[0bin011011001101] = 0bin0); +ASSERT (Y[0bin010110001010] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin010110001010] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin010110001010] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin010110001010] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010110001010] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010110001010] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010110001011] & Y[0bin010110111010] = 0bin0); +ASSERT (Y[0bin010110001011] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010110001011] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010110001011] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010110001011] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010110001011] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010110001011] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010110001011] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010110001011] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010110001011] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010110001011] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010110001011] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010110001011] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010110001011] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010110001011] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010110001011] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010110001011] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010110001011] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010110001011] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010110001011] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010110001011] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010110001011] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010110001011] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010110001011] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010110001011] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin010110001011] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010110001011] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010110001011] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010110001011] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010110001011] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010110001011] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin010110001011] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin010110001011] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010110001011] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010110001011] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010110001011] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010110001011] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin010110001011] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin010110001011] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin010110001011] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010110001011] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010110001011] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010110001011] & Y[0bin011011111100] = 0bin0); +ASSERT (Y[0bin010110001011] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin010110001011] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin010110001011] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin010110001011] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010110001011] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010110001100] & Y[0bin010110111011] = 0bin0); +ASSERT (Y[0bin010110001100] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010110001100] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010110001100] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010110001100] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010110001100] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010110001100] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010110001100] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010110001100] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010110001100] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010110001100] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010110001100] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010110001100] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010110001100] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010110001100] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010110001100] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010110001100] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010110001100] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010110001100] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010110001100] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010110001100] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010110001100] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010110001100] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010110001100] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010110001100] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010110001100] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin010110001100] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010110001100] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010110001100] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010110001100] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010110001100] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin010110001100] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin010110001100] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010110001100] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010110001100] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010110001100] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin010110001100] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin010110001100] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin010110001100] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010110001100] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010110001100] & Y[0bin011100101011] = 0bin0); +ASSERT (Y[0bin010110001100] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin010110001100] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin010110001100] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin010110001100] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010110001101] & Y[0bin010110111100] = 0bin0); +ASSERT (Y[0bin010110001101] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010110001101] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010110001101] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010110001101] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010110001101] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010110001101] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010110001101] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010110001101] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010110001101] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010110001101] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010110001101] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010110001101] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010110001101] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010110001101] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010110001101] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010110001101] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010110001101] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010110001101] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010110001101] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010110001101] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010110001101] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010110001101] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010110001101] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010110001101] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin010110001101] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010110001101] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010110001101] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010110001101] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin010110001101] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin010110001101] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010110001101] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010110001101] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin010110001101] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin010110001101] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin010110001101] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010110001101] & Y[0bin011101011010] = 0bin0); +ASSERT (Y[0bin010110001101] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin010110001101] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin010110001101] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin010110001110] & Y[0bin010110111101] = 0bin0); +ASSERT (Y[0bin010110001110] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010110001110] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010110001110] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010110001110] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010110001110] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010110001110] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010110001110] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010110001110] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010110001110] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010110001110] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010110001110] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010110001110] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010110001110] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010110001110] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010110001110] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010110001110] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010110001110] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010110001110] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010110001110] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010110001110] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010110001110] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin010110001110] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010110001110] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010110001110] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin010110001110] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin010110001110] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010110001110] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin010110001110] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin010110001110] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin010110001110] & Y[0bin011110001001] = 0bin0); +ASSERT (Y[0bin010110001110] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin010110001110] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin010110001111] & Y[0bin010110111110] = 0bin0); +ASSERT (Y[0bin010110001111] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010110001111] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010110001111] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010110001111] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010110001111] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010110001111] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010110001111] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010110001111] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010110001111] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010110001111] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010110001111] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010110001111] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010110001111] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010110001111] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010110001111] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010110001111] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin010110001111] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010110001111] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin010110001111] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin010110001111] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin010110001111] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin010110001111] & Y[0bin011110111000] = 0bin0); +ASSERT (Y[0bin010110001111] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin010110010000] & Y[0bin010110111111] = 0bin0); +ASSERT (Y[0bin010110010000] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010110010000] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010110010000] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010110010000] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010110010000] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010110010000] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010110010000] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010110010000] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010110010000] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin010110010000] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin010110010000] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin010110010000] & Y[0bin011111100111] = 0bin0); +ASSERT (Y[0bin010110110011] & Y[0bin010111100010] = 0bin0); +ASSERT (Y[0bin010110110011] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin010110110011] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin010110110011] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin010110110011] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin010110110011] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010110110011] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010110110011] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010110110011] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010110110011] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010110110011] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010110110011] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010110110100] & Y[0bin010111100011] = 0bin0); +ASSERT (Y[0bin010110110100] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin010110110100] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin010110110100] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin010110110100] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010110110100] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010110110100] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010110110100] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010110110100] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010110110100] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010110110100] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010110110100] & Y[0bin011000010001] = 0bin0); +ASSERT (Y[0bin010110110100] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin010110110100] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin010110110100] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin010110110100] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010110110100] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010110110100] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010110110100] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010110110100] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010110110100] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010110110100] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010110110101] & Y[0bin010111100100] = 0bin0); +ASSERT (Y[0bin010110110101] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin010110110101] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin010110110101] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010110110101] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010110110101] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010110110101] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010110110101] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010110110101] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010110110101] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010110110101] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin010110110101] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin010110110101] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin010110110101] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010110110101] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010110110101] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010110110101] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010110110101] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010110110101] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010110110101] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010110110101] & Y[0bin011001000000] = 0bin0); +ASSERT (Y[0bin010110110101] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin010110110101] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin010110110101] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin010110110101] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010110110101] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010110110101] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010110110101] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010110110101] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010110110101] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010110110110] & Y[0bin010111100101] = 0bin0); +ASSERT (Y[0bin010110110110] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin010110110110] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010110110110] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010110110110] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010110110110] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010110110110] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010110110110] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010110110110] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010110110110] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin010110110110] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin010110110110] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010110110110] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010110110110] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010110110110] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010110110110] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010110110110] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010110110110] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010110110110] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin010110110110] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin010110110110] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin010110110110] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010110110110] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010110110110] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010110110110] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010110110110] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010110110110] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010110110110] & Y[0bin011001101111] = 0bin0); +ASSERT (Y[0bin010110110110] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin010110110110] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin010110110110] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin010110110110] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010110110110] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010110110110] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010110110110] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010110110110] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010110110111] & Y[0bin010111100110] = 0bin0); +ASSERT (Y[0bin010110110111] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010110110111] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010110110111] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010110110111] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010110110111] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010110110111] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010110110111] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010110110111] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin010110110111] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010110110111] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010110110111] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010110110111] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010110110111] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010110110111] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010110110111] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010110110111] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin010110110111] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin010110110111] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010110110111] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010110110111] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010110110111] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010110110111] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010110110111] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010110110111] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin010110110111] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin010110110111] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin010110110111] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010110110111] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010110110111] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010110110111] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010110110111] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010110110111] & Y[0bin011010011110] = 0bin0); +ASSERT (Y[0bin010110110111] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin010110110111] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin010110110111] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin010110110111] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010110110111] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010110110111] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010110110111] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010110111000] & Y[0bin010111100111] = 0bin0); +ASSERT (Y[0bin010110111000] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010110111000] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010110111000] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010110111000] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010110111000] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010110111000] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010110111000] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010110111000] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010110111000] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010110111000] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010110111000] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010110111000] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010110111000] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010110111000] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin010110111000] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010110111000] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010110111000] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010110111000] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010110111000] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010110111000] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010110111000] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin010110111000] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin010110111000] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010110111000] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010110111000] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010110111000] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010110111000] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010110111000] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin010110111000] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin010110111000] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin010110111000] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010110111000] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010110111000] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010110111000] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010110111000] & Y[0bin011011001101] = 0bin0); +ASSERT (Y[0bin010110111000] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin010110111000] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin010110111000] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin010110111000] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010110111000] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010110111000] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010110111001] & Y[0bin010111101000] = 0bin0); +ASSERT (Y[0bin010110111001] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010110111001] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010110111001] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010110111001] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010110111001] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010110111001] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010110111001] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010110111001] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010110111001] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010110111001] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010110111001] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010110111001] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010110111001] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010110111001] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010110111001] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010110111001] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010110111001] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010110111001] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin010110111001] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010110111001] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010110111001] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010110111001] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010110111001] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010110111001] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin010110111001] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin010110111001] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010110111001] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010110111001] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010110111001] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010110111001] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin010110111001] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin010110111001] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin010110111001] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010110111001] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010110111001] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010110111001] & Y[0bin011011111100] = 0bin0); +ASSERT (Y[0bin010110111001] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin010110111001] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin010110111001] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin010110111001] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010110111001] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010110111010] & Y[0bin010111101001] = 0bin0); +ASSERT (Y[0bin010110111010] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010110111010] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010110111010] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010110111010] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010110111010] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010110111010] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010110111010] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010110111010] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010110111010] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010110111010] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010110111010] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010110111010] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010110111010] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010110111010] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010110111010] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010110111010] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010110111010] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010110111010] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010110111010] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010110111010] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin010110111010] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010110111010] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010110111010] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010110111010] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010110111010] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin010110111010] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin010110111010] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010110111010] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010110111010] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010110111010] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin010110111010] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin010110111010] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin010110111010] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010110111010] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010110111010] & Y[0bin011100101011] = 0bin0); +ASSERT (Y[0bin010110111010] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin010110111010] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin010110111010] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin010110111010] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010110111011] & Y[0bin010111101010] = 0bin0); +ASSERT (Y[0bin010110111011] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010110111011] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010110111011] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010110111011] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010110111011] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010110111011] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010110111011] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010110111011] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010110111011] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010110111011] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010110111011] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010110111011] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010110111011] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010110111011] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010110111011] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010110111011] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010110111011] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010110111011] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010110111011] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010110111011] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin010110111011] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010110111011] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010110111011] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010110111011] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin010110111011] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin010110111011] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010110111011] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010110111011] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin010110111011] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin010110111011] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin010110111011] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010110111011] & Y[0bin011101011010] = 0bin0); +ASSERT (Y[0bin010110111011] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin010110111011] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin010110111011] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin010110111100] & Y[0bin010111101011] = 0bin0); +ASSERT (Y[0bin010110111100] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010110111100] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010110111100] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010110111100] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010110111100] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010110111100] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010110111100] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010110111100] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010110111100] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010110111100] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010110111100] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010110111100] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010110111100] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010110111100] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010110111100] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010110111100] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010110111100] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010110111100] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin010110111100] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010110111100] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010110111100] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin010110111100] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin010110111100] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010110111100] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin010110111100] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin010110111100] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin010110111100] & Y[0bin011110001001] = 0bin0); +ASSERT (Y[0bin010110111100] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin010110111100] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin010110111101] & Y[0bin010111101100] = 0bin0); +ASSERT (Y[0bin010110111101] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010110111101] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010110111101] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010110111101] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010110111101] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010110111101] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010110111101] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010110111101] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010110111101] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010110111101] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010110111101] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010110111101] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010110111101] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010110111101] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin010110111101] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010110111101] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin010110111101] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin010110111101] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin010110111101] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin010110111101] & Y[0bin011110111000] = 0bin0); +ASSERT (Y[0bin010110111101] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin010110111110] & Y[0bin010111101101] = 0bin0); +ASSERT (Y[0bin010110111110] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010110111110] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010110111110] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010110111110] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010110111110] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010110111110] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010110111110] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010110111110] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin010110111110] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin010110111110] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin010110111110] & Y[0bin011111100111] = 0bin0); +ASSERT (Y[0bin010111100010] & Y[0bin011000010001] = 0bin0); +ASSERT (Y[0bin010111100010] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin010111100010] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin010111100010] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin010111100010] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010111100010] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010111100010] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010111100010] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010111100010] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010111100010] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010111100010] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010111100011] & Y[0bin011000010010] = 0bin0); +ASSERT (Y[0bin010111100011] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin010111100011] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin010111100011] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010111100011] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010111100011] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010111100011] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010111100011] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010111100011] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010111100011] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010111100011] & Y[0bin011001000000] = 0bin0); +ASSERT (Y[0bin010111100011] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin010111100011] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin010111100011] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin010111100011] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010111100011] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010111100011] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010111100011] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010111100011] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010111100011] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010111100100] & Y[0bin011000010011] = 0bin0); +ASSERT (Y[0bin010111100100] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin010111100100] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010111100100] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010111100100] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010111100100] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010111100100] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010111100100] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010111100100] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010111100100] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin010111100100] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin010111100100] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin010111100100] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010111100100] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010111100100] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010111100100] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010111100100] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010111100100] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010111100100] & Y[0bin011001101111] = 0bin0); +ASSERT (Y[0bin010111100100] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin010111100100] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin010111100100] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin010111100100] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010111100100] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010111100100] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010111100100] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010111100100] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010111100101] & Y[0bin011000010100] = 0bin0); +ASSERT (Y[0bin010111100101] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010111100101] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010111100101] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010111100101] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010111100101] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010111100101] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010111100101] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010111100101] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin010111100101] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin010111100101] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010111100101] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010111100101] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010111100101] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010111100101] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010111100101] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010111100101] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin010111100101] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin010111100101] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin010111100101] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010111100101] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010111100101] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010111100101] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010111100101] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010111100101] & Y[0bin011010011110] = 0bin0); +ASSERT (Y[0bin010111100101] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin010111100101] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin010111100101] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin010111100101] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010111100101] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010111100101] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010111100101] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010111100110] & Y[0bin011000010101] = 0bin0); +ASSERT (Y[0bin010111100110] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010111100110] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010111100110] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010111100110] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010111100110] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010111100110] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010111100110] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin010111100110] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010111100110] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010111100110] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010111100110] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010111100110] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010111100110] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010111100110] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin010111100110] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin010111100110] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010111100110] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010111100110] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010111100110] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010111100110] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010111100110] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin010111100110] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin010111100110] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin010111100110] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010111100110] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010111100110] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010111100110] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010111100110] & Y[0bin011011001101] = 0bin0); +ASSERT (Y[0bin010111100110] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin010111100110] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin010111100110] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin010111100110] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010111100110] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010111100110] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010111100111] & Y[0bin011000010110] = 0bin0); +ASSERT (Y[0bin010111100111] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010111100111] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010111100111] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010111100111] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010111100111] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010111100111] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin010111100111] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010111100111] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010111100111] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010111100111] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010111100111] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010111100111] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin010111100111] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010111100111] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010111100111] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010111100111] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010111100111] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010111100111] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin010111100111] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin010111100111] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010111100111] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010111100111] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010111100111] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010111100111] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin010111100111] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin010111100111] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin010111100111] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010111100111] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010111100111] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010111100111] & Y[0bin011011111100] = 0bin0); +ASSERT (Y[0bin010111100111] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin010111100111] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin010111100111] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin010111100111] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010111100111] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010111101000] & Y[0bin011000010111] = 0bin0); +ASSERT (Y[0bin010111101000] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010111101000] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010111101000] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010111101000] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010111101000] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin010111101000] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010111101000] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010111101000] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010111101000] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010111101000] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin010111101000] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010111101000] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010111101000] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010111101000] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010111101000] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin010111101000] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010111101000] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010111101000] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010111101000] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010111101000] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin010111101000] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin010111101000] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010111101000] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010111101000] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010111101000] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin010111101000] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin010111101000] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin010111101000] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010111101000] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010111101000] & Y[0bin011100101011] = 0bin0); +ASSERT (Y[0bin010111101000] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin010111101000] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin010111101000] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin010111101000] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010111101001] & Y[0bin011000011000] = 0bin0); +ASSERT (Y[0bin010111101001] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010111101001] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010111101001] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010111101001] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin010111101001] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010111101001] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010111101001] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010111101001] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin010111101001] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010111101001] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010111101001] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010111101001] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin010111101001] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010111101001] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010111101001] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010111101001] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin010111101001] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010111101001] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010111101001] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010111101001] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin010111101001] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin010111101001] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010111101001] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010111101001] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin010111101001] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin010111101001] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin010111101001] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010111101001] & Y[0bin011101011010] = 0bin0); +ASSERT (Y[0bin010111101001] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin010111101001] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin010111101001] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin010111101010] & Y[0bin011000011001] = 0bin0); +ASSERT (Y[0bin010111101010] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010111101010] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010111101010] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin010111101010] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010111101010] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010111101010] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin010111101010] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010111101010] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010111101010] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin010111101010] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010111101010] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010111101010] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin010111101010] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010111101010] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010111101010] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin010111101010] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010111101010] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010111101010] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin010111101010] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin010111101010] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010111101010] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin010111101010] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin010111101010] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin010111101010] & Y[0bin011110001001] = 0bin0); +ASSERT (Y[0bin010111101010] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin010111101010] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin010111101011] & Y[0bin011000011010] = 0bin0); +ASSERT (Y[0bin010111101011] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010111101011] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin010111101011] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010111101011] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin010111101011] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010111101011] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin010111101011] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010111101011] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin010111101011] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010111101011] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin010111101011] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010111101011] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin010111101011] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010111101011] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin010111101011] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin010111101011] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin010111101011] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin010111101011] & Y[0bin011110111000] = 0bin0); +ASSERT (Y[0bin010111101011] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin010111101100] & Y[0bin011000011011] = 0bin0); +ASSERT (Y[0bin010111101100] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin010111101100] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin010111101100] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin010111101100] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin010111101100] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin010111101100] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin010111101100] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin010111101100] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin010111101100] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin010111101100] & Y[0bin011111100111] = 0bin0); +ASSERT (Y[0bin011000010001] & Y[0bin011001000000] = 0bin0); +ASSERT (Y[0bin011000010001] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin011000010001] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin011000010001] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin011000010001] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin011000010001] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin011000010001] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin011000010001] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin011000010001] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin011000010001] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin011000010010] & Y[0bin011001000001] = 0bin0); +ASSERT (Y[0bin011000010010] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin011000010010] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin011000010010] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin011000010010] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin011000010010] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin011000010010] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin011000010010] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin011000010010] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin011000010010] & Y[0bin011001101111] = 0bin0); +ASSERT (Y[0bin011000010010] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin011000010010] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin011000010010] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin011000010010] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin011000010010] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin011000010010] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin011000010010] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin011000010010] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin011000010011] & Y[0bin011001000010] = 0bin0); +ASSERT (Y[0bin011000010011] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin011000010011] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin011000010011] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin011000010011] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin011000010011] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin011000010011] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin011000010011] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin011000010011] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin011000010011] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin011000010011] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin011000010011] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin011000010011] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin011000010011] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin011000010011] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin011000010011] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin011000010011] & Y[0bin011010011110] = 0bin0); +ASSERT (Y[0bin011000010011] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin011000010011] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin011000010011] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin011000010011] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin011000010011] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin011000010011] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin011000010011] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin011000010100] & Y[0bin011001000011] = 0bin0); +ASSERT (Y[0bin011000010100] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin011000010100] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin011000010100] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin011000010100] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin011000010100] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin011000010100] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin011000010100] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin011000010100] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin011000010100] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin011000010100] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin011000010100] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin011000010100] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin011000010100] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin011000010100] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin011000010100] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin011000010100] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin011000010100] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin011000010100] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin011000010100] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin011000010100] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin011000010100] & Y[0bin011011001101] = 0bin0); +ASSERT (Y[0bin011000010100] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin011000010100] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin011000010100] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin011000010100] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin011000010100] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin011000010100] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin011000010101] & Y[0bin011001000100] = 0bin0); +ASSERT (Y[0bin011000010101] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin011000010101] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin011000010101] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin011000010101] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin011000010101] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin011000010101] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin011000010101] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin011000010101] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin011000010101] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin011000010101] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin011000010101] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin011000010101] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin011000010101] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin011000010101] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin011000010101] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin011000010101] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin011000010101] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin011000010101] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin011000010101] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin011000010101] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin011000010101] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin011000010101] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin011000010101] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin011000010101] & Y[0bin011011111100] = 0bin0); +ASSERT (Y[0bin011000010101] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin011000010101] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin011000010101] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin011000010101] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin011000010101] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin011000010110] & Y[0bin011001000101] = 0bin0); +ASSERT (Y[0bin011000010110] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin011000010110] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin011000010110] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin011000010110] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin011000010110] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin011000010110] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin011000010110] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin011000010110] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin011000010110] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin011000010110] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin011000010110] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin011000010110] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin011000010110] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin011000010110] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin011000010110] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin011000010110] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin011000010110] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin011000010110] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin011000010110] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin011000010110] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin011000010110] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin011000010110] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin011000010110] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin011000010110] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin011000010110] & Y[0bin011100101011] = 0bin0); +ASSERT (Y[0bin011000010110] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin011000010110] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin011000010110] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin011000010110] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin011000010111] & Y[0bin011001000110] = 0bin0); +ASSERT (Y[0bin011000010111] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin011000010111] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin011000010111] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin011000010111] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin011000010111] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin011000010111] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin011000010111] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin011000010111] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin011000010111] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin011000010111] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin011000010111] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin011000010111] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin011000010111] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin011000010111] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin011000010111] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin011000010111] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin011000010111] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin011000010111] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin011000010111] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin011000010111] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin011000010111] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin011000010111] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin011000010111] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin011000010111] & Y[0bin011101011010] = 0bin0); +ASSERT (Y[0bin011000010111] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin011000010111] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin011000010111] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin011000011000] & Y[0bin011001000111] = 0bin0); +ASSERT (Y[0bin011000011000] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin011000011000] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin011000011000] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin011000011000] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin011000011000] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin011000011000] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin011000011000] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin011000011000] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin011000011000] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin011000011000] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin011000011000] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin011000011000] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin011000011000] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin011000011000] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin011000011000] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin011000011000] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin011000011000] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin011000011000] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin011000011000] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin011000011000] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin011000011000] & Y[0bin011110001001] = 0bin0); +ASSERT (Y[0bin011000011000] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin011000011000] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin011000011001] & Y[0bin011001001000] = 0bin0); +ASSERT (Y[0bin011000011001] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin011000011001] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin011000011001] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin011000011001] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin011000011001] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin011000011001] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin011000011001] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin011000011001] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin011000011001] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin011000011001] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin011000011001] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin011000011001] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin011000011001] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin011000011001] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin011000011001] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin011000011001] & Y[0bin011110111000] = 0bin0); +ASSERT (Y[0bin011000011001] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin011000011010] & Y[0bin011001001001] = 0bin0); +ASSERT (Y[0bin011000011010] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin011000011010] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin011000011010] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin011000011010] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin011000011010] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin011000011010] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin011000011010] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin011000011010] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin011000011010] & Y[0bin011111100111] = 0bin0); +ASSERT (Y[0bin011001000000] & Y[0bin011001101111] = 0bin0); +ASSERT (Y[0bin011001000000] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin011001000000] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin011001000000] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin011001000000] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin011001000000] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin011001000000] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin011001000000] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin011001000000] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin011001000001] & Y[0bin011001110000] = 0bin0); +ASSERT (Y[0bin011001000001] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin011001000001] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin011001000001] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin011001000001] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin011001000001] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin011001000001] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin011001000001] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin011001000001] & Y[0bin011010011110] = 0bin0); +ASSERT (Y[0bin011001000001] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin011001000001] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin011001000001] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin011001000001] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin011001000001] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin011001000001] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin011001000001] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin011001000010] & Y[0bin011001110001] = 0bin0); +ASSERT (Y[0bin011001000010] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin011001000010] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin011001000010] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin011001000010] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin011001000010] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin011001000010] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin011001000010] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin011001000010] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin011001000010] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin011001000010] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin011001000010] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin011001000010] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin011001000010] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin011001000010] & Y[0bin011011001101] = 0bin0); +ASSERT (Y[0bin011001000010] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin011001000010] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin011001000010] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin011001000010] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin011001000010] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin011001000010] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin011001000011] & Y[0bin011001110010] = 0bin0); +ASSERT (Y[0bin011001000011] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin011001000011] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin011001000011] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin011001000011] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin011001000011] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin011001000011] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin011001000011] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin011001000011] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin011001000011] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin011001000011] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin011001000011] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin011001000011] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin011001000011] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin011001000011] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin011001000011] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin011001000011] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin011001000011] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin011001000011] & Y[0bin011011111100] = 0bin0); +ASSERT (Y[0bin011001000011] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin011001000011] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin011001000011] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin011001000011] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin011001000011] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin011001000100] & Y[0bin011001110011] = 0bin0); +ASSERT (Y[0bin011001000100] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin011001000100] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin011001000100] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin011001000100] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin011001000100] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin011001000100] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin011001000100] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin011001000100] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin011001000100] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin011001000100] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin011001000100] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin011001000100] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin011001000100] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin011001000100] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin011001000100] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin011001000100] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin011001000100] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin011001000100] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin011001000100] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin011001000100] & Y[0bin011100101011] = 0bin0); +ASSERT (Y[0bin011001000100] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin011001000100] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin011001000100] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin011001000100] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin011001000101] & Y[0bin011001110100] = 0bin0); +ASSERT (Y[0bin011001000101] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin011001000101] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin011001000101] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin011001000101] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin011001000101] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin011001000101] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin011001000101] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin011001000101] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin011001000101] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin011001000101] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin011001000101] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin011001000101] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin011001000101] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin011001000101] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin011001000101] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin011001000101] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin011001000101] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin011001000101] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin011001000101] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin011001000101] & Y[0bin011101011010] = 0bin0); +ASSERT (Y[0bin011001000101] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin011001000101] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin011001000101] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin011001000110] & Y[0bin011001110101] = 0bin0); +ASSERT (Y[0bin011001000110] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin011001000110] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin011001000110] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin011001000110] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin011001000110] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin011001000110] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin011001000110] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin011001000110] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin011001000110] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin011001000110] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin011001000110] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin011001000110] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin011001000110] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin011001000110] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin011001000110] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin011001000110] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin011001000110] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin011001000110] & Y[0bin011110001001] = 0bin0); +ASSERT (Y[0bin011001000110] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin011001000110] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin011001000111] & Y[0bin011001110110] = 0bin0); +ASSERT (Y[0bin011001000111] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin011001000111] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin011001000111] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin011001000111] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin011001000111] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin011001000111] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin011001000111] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin011001000111] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin011001000111] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin011001000111] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin011001000111] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin011001000111] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin011001000111] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin011001000111] & Y[0bin011110111000] = 0bin0); +ASSERT (Y[0bin011001000111] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin011001001000] & Y[0bin011001110111] = 0bin0); +ASSERT (Y[0bin011001001000] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin011001001000] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin011001001000] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin011001001000] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin011001001000] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin011001001000] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin011001001000] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin011001001000] & Y[0bin011111100111] = 0bin0); +ASSERT (Y[0bin011001101111] & Y[0bin011010011110] = 0bin0); +ASSERT (Y[0bin011001101111] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin011001101111] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin011001101111] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin011001101111] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin011001101111] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin011001101111] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin011001101111] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin011001110000] & Y[0bin011010011111] = 0bin0); +ASSERT (Y[0bin011001110000] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin011001110000] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin011001110000] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin011001110000] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin011001110000] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin011001110000] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin011001110000] & Y[0bin011011001101] = 0bin0); +ASSERT (Y[0bin011001110000] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin011001110000] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin011001110000] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin011001110000] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin011001110000] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin011001110000] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin011001110001] & Y[0bin011010100000] = 0bin0); +ASSERT (Y[0bin011001110001] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin011001110001] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin011001110001] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin011001110001] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin011001110001] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin011001110001] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin011001110001] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin011001110001] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin011001110001] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin011001110001] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin011001110001] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin011001110001] & Y[0bin011011111100] = 0bin0); +ASSERT (Y[0bin011001110001] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin011001110001] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin011001110001] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin011001110001] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin011001110001] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin011001110010] & Y[0bin011010100001] = 0bin0); +ASSERT (Y[0bin011001110010] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin011001110010] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin011001110010] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin011001110010] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin011001110010] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin011001110010] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin011001110010] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin011001110010] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin011001110010] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin011001110010] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin011001110010] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin011001110010] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin011001110010] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin011001110010] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin011001110010] & Y[0bin011100101011] = 0bin0); +ASSERT (Y[0bin011001110010] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin011001110010] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin011001110010] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin011001110010] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin011001110011] & Y[0bin011010100010] = 0bin0); +ASSERT (Y[0bin011001110011] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin011001110011] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin011001110011] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin011001110011] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin011001110011] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin011001110011] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin011001110011] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin011001110011] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin011001110011] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin011001110011] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin011001110011] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin011001110011] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin011001110011] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin011001110011] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin011001110011] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin011001110011] & Y[0bin011101011010] = 0bin0); +ASSERT (Y[0bin011001110011] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin011001110011] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin011001110011] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin011001110100] & Y[0bin011010100011] = 0bin0); +ASSERT (Y[0bin011001110100] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin011001110100] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin011001110100] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin011001110100] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin011001110100] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin011001110100] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin011001110100] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin011001110100] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin011001110100] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin011001110100] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin011001110100] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin011001110100] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin011001110100] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin011001110100] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin011001110100] & Y[0bin011110001001] = 0bin0); +ASSERT (Y[0bin011001110100] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin011001110100] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin011001110101] & Y[0bin011010100100] = 0bin0); +ASSERT (Y[0bin011001110101] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin011001110101] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin011001110101] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin011001110101] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin011001110101] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin011001110101] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin011001110101] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin011001110101] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin011001110101] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin011001110101] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin011001110101] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin011001110101] & Y[0bin011110111000] = 0bin0); +ASSERT (Y[0bin011001110101] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin011001110110] & Y[0bin011010100101] = 0bin0); +ASSERT (Y[0bin011001110110] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin011001110110] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin011001110110] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin011001110110] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin011001110110] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin011001110110] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin011001110110] & Y[0bin011111100111] = 0bin0); +ASSERT (Y[0bin011010011110] & Y[0bin011011001101] = 0bin0); +ASSERT (Y[0bin011010011110] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin011010011110] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin011010011110] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin011010011110] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin011010011110] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin011010011110] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin011010011111] & Y[0bin011011001110] = 0bin0); +ASSERT (Y[0bin011010011111] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin011010011111] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin011010011111] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin011010011111] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin011010011111] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin011010011111] & Y[0bin011011111100] = 0bin0); +ASSERT (Y[0bin011010011111] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin011010011111] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin011010011111] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin011010011111] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin011010011111] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin011010100000] & Y[0bin011011001111] = 0bin0); +ASSERT (Y[0bin011010100000] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin011010100000] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin011010100000] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin011010100000] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin011010100000] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin011010100000] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin011010100000] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin011010100000] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin011010100000] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin011010100000] & Y[0bin011100101011] = 0bin0); +ASSERT (Y[0bin011010100000] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin011010100000] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin011010100000] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin011010100000] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin011010100001] & Y[0bin011011010000] = 0bin0); +ASSERT (Y[0bin011010100001] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin011010100001] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin011010100001] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin011010100001] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin011010100001] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin011010100001] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin011010100001] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin011010100001] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin011010100001] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin011010100001] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin011010100001] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin011010100001] & Y[0bin011101011010] = 0bin0); +ASSERT (Y[0bin011010100001] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin011010100001] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin011010100001] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin011010100010] & Y[0bin011011010001] = 0bin0); +ASSERT (Y[0bin011010100010] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin011010100010] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin011010100010] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin011010100010] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin011010100010] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin011010100010] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin011010100010] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin011010100010] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin011010100010] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin011010100010] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin011010100010] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin011010100010] & Y[0bin011110001001] = 0bin0); +ASSERT (Y[0bin011010100010] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin011010100010] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin011010100011] & Y[0bin011011010010] = 0bin0); +ASSERT (Y[0bin011010100011] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin011010100011] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin011010100011] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin011010100011] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin011010100011] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin011010100011] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin011010100011] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin011010100011] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin011010100011] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin011010100011] & Y[0bin011110111000] = 0bin0); +ASSERT (Y[0bin011010100011] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin011010100100] & Y[0bin011011010011] = 0bin0); +ASSERT (Y[0bin011010100100] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin011010100100] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin011010100100] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin011010100100] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin011010100100] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin011010100100] & Y[0bin011111100111] = 0bin0); +ASSERT (Y[0bin011011001101] & Y[0bin011011111100] = 0bin0); +ASSERT (Y[0bin011011001101] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin011011001101] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin011011001101] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin011011001101] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin011011001101] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin011011001110] & Y[0bin011011111101] = 0bin0); +ASSERT (Y[0bin011011001110] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin011011001110] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin011011001110] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin011011001110] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin011011001110] & Y[0bin011100101011] = 0bin0); +ASSERT (Y[0bin011011001110] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin011011001110] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin011011001110] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin011011001110] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin011011001111] & Y[0bin011011111110] = 0bin0); +ASSERT (Y[0bin011011001111] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin011011001111] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin011011001111] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin011011001111] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin011011001111] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin011011001111] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin011011001111] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin011011001111] & Y[0bin011101011010] = 0bin0); +ASSERT (Y[0bin011011001111] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin011011001111] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin011011001111] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin011011010000] & Y[0bin011011111111] = 0bin0); +ASSERT (Y[0bin011011010000] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin011011010000] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin011011010000] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin011011010000] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin011011010000] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin011011010000] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin011011010000] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin011011010000] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin011011010000] & Y[0bin011110001001] = 0bin0); +ASSERT (Y[0bin011011010000] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin011011010000] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin011011010001] & Y[0bin011100000000] = 0bin0); +ASSERT (Y[0bin011011010001] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin011011010001] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin011011010001] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin011011010001] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin011011010001] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin011011010001] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin011011010001] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin011011010001] & Y[0bin011110111000] = 0bin0); +ASSERT (Y[0bin011011010001] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin011011010010] & Y[0bin011100000001] = 0bin0); +ASSERT (Y[0bin011011010010] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin011011010010] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin011011010010] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin011011010010] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin011011010010] & Y[0bin011111100111] = 0bin0); +ASSERT (Y[0bin011011111100] & Y[0bin011100101011] = 0bin0); +ASSERT (Y[0bin011011111100] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin011011111100] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin011011111100] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin011011111100] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin011011111101] & Y[0bin011100101100] = 0bin0); +ASSERT (Y[0bin011011111101] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin011011111101] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin011011111101] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin011011111101] & Y[0bin011101011010] = 0bin0); +ASSERT (Y[0bin011011111101] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin011011111101] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin011011111101] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin011011111110] & Y[0bin011100101101] = 0bin0); +ASSERT (Y[0bin011011111110] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin011011111110] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin011011111110] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin011011111110] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin011011111110] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin011011111110] & Y[0bin011110001001] = 0bin0); +ASSERT (Y[0bin011011111110] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin011011111110] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin011011111111] & Y[0bin011100101110] = 0bin0); +ASSERT (Y[0bin011011111111] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin011011111111] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin011011111111] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin011011111111] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin011011111111] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin011011111111] & Y[0bin011110111000] = 0bin0); +ASSERT (Y[0bin011011111111] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin011100000000] & Y[0bin011100101111] = 0bin0); +ASSERT (Y[0bin011100000000] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin011100000000] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin011100000000] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin011100000000] & Y[0bin011111100111] = 0bin0); +ASSERT (Y[0bin011100101011] & Y[0bin011101011010] = 0bin0); +ASSERT (Y[0bin011100101011] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin011100101011] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin011100101011] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin011100101100] & Y[0bin011101011011] = 0bin0); +ASSERT (Y[0bin011100101100] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin011100101100] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin011100101100] & Y[0bin011110001001] = 0bin0); +ASSERT (Y[0bin011100101100] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin011100101100] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin011100101101] & Y[0bin011101011100] = 0bin0); +ASSERT (Y[0bin011100101101] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin011100101101] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin011100101101] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin011100101101] & Y[0bin011110111000] = 0bin0); +ASSERT (Y[0bin011100101101] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin011100101110] & Y[0bin011101011101] = 0bin0); +ASSERT (Y[0bin011100101110] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin011100101110] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin011100101110] & Y[0bin011111100111] = 0bin0); +ASSERT (Y[0bin011101011010] & Y[0bin011110001001] = 0bin0); +ASSERT (Y[0bin011101011010] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin011101011010] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin011101011011] & Y[0bin011110001010] = 0bin0); +ASSERT (Y[0bin011101011011] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin011101011011] & Y[0bin011110111000] = 0bin0); +ASSERT (Y[0bin011101011011] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin011101011100] & Y[0bin011110001011] = 0bin0); +ASSERT (Y[0bin011101011100] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin011101011100] & Y[0bin011111100111] = 0bin0); +ASSERT (Y[0bin011110001001] & Y[0bin011110111000] = 0bin0); +ASSERT (Y[0bin011110001001] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin011110001010] & Y[0bin011110111001] = 0bin0); +ASSERT (Y[0bin011110001010] & Y[0bin011111100111] = 0bin0); +ASSERT (Y[0bin011110111000] & Y[0bin011111100111] = 0bin0); + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +% Objective function +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +total_energy : BITVECTOR(16); +ASSERT(total_energy = BVPLUS(16, BVPLUS(16, 0bin00000000@final_Ex[0bin000000000111], 0bin00000000@final_Ey[0bin000000000111]), BVPLUS(16, 0bin00000000@final_Ex[0bin000000010000], 0bin00000000@final_Ey[0bin000000010000]), BVPLUS(16, 0bin00000000@final_Ex[0bin000000010010], 0bin00000000@final_Ey[0bin000000010010]), BVPLUS(16, 0bin00000000@final_Ex[0bin000000010110], 0bin00000000@final_Ey[0bin000000010110]), BVPLUS(16, 0bin00000000@final_Ex[0bin000000011001], 0bin00000000@final_Ey[0bin000000011001]), BVPLUS(16, 0bin00000000@final_Ex[0bin000000011100], 0bin00000000@final_Ey[0bin000000011100]), BVPLUS(16, 0bin00000000@final_Ex[0bin000000011111], 0bin00000000@final_Ey[0bin000000011111]), BVPLUS(16, 0bin00000000@final_Ex[0bin000000101011], 0bin00000000@final_Ey[0bin000000101011]), BVPLUS(16, 0bin00000000@final_Ex[0bin000000101101], 0bin00000000@final_Ey[0bin000000101101]), BVPLUS(16, 0bin00000000@final_Ex[0bin000000111111], 0bin00000000@final_Ey[0bin000000111111]), BVPLUS(16, 0bin00000000@final_Ex[0bin000001011010], 0bin00000000@final_Ey[0bin000001011010]), BVPLUS(16, 0bin00000000@final_Ex[0bin000001101100], 0bin00000000@final_Ey[0bin000001101100]), BVPLUS(16, 0bin00000000@final_Ex[0bin000001111011], 0bin00000000@final_Ey[0bin000001111011]), BVPLUS(16, 0bin00000000@final_Ex[0bin000010000111], 0bin00000000@final_Ey[0bin000010000111]), BVPLUS(16, 0bin00000000@final_Ex[0bin000010010000], 0bin00000000@final_Ey[0bin000010010000]), BVPLUS(16, 0bin00000000@final_Ex[0bin000010101000], 0bin00000000@final_Ey[0bin000010101000]), BVPLUS(16, 0bin00000000@final_Ex[0bin000010110000], 0bin00000000@final_Ey[0bin000010110000]), BVPLUS(16, 0bin00000000@final_Ex[0bin000010110011], 0bin00000000@final_Ey[0bin000010110011]), BVPLUS(16, 0bin00000000@final_Ex[0bin000010110100], 0bin00000000@final_Ey[0bin000010110100]), BVPLUS(16, 0bin00000000@final_Ex[0bin000011000111], 0bin00000000@final_Ey[0bin000011000111]), BVPLUS(16, 0bin00000000@final_Ex[0bin000011001001], 0bin00000000@final_Ey[0bin000011001001]), BVPLUS(16, 0bin00000000@final_Ex[0bin000011010011], 0bin00000000@final_Ey[0bin000011010011]), BVPLUS(16, 0bin00000000@final_Ex[0bin000011010101], 0bin00000000@final_Ey[0bin000011010101]), BVPLUS(16, 0bin00000000@final_Ex[0bin000011011101], 0bin00000000@final_Ey[0bin000011011101]), BVPLUS(16, 0bin00000000@final_Ex[0bin000011100100], 0bin00000000@final_Ey[0bin000011100100]), BVPLUS(16, 0bin00000000@final_Ex[0bin000011101010], 0bin00000000@final_Ey[0bin000011101010]), BVPLUS(16, 0bin00000000@final_Ex[0bin000011101110], 0bin00000000@final_Ey[0bin000011101110]), BVPLUS(16, 0bin00000000@final_Ex[0bin000011110010], 0bin00000000@final_Ey[0bin000011110010]), BVPLUS(16, 0bin00000000@final_Ex[0bin000011110011], 0bin00000000@final_Ey[0bin000011110011]), BVPLUS(16, 0bin00000000@final_Ex[0bin000011110100], 0bin00000000@final_Ey[0bin000011110100]), BVPLUS(16, 0bin00000000@final_Ex[0bin000011111001], 0bin00000000@final_Ey[0bin000011111001]), BVPLUS(16, 0bin00000000@final_Ex[0bin000100000000], 0bin00000000@final_Ey[0bin000100000000]), BVPLUS(16, 0bin00000000@final_Ex[0bin000100010101], 0bin00000000@final_Ey[0bin000100010101]), BVPLUS(16, 0bin00000000@final_Ex[0bin000100100100], 0bin00000000@final_Ey[0bin000100100100]), BVPLUS(16, 0bin00000000@final_Ex[0bin000100100110], 0bin00000000@final_Ey[0bin000100100110]), BVPLUS(16, 0bin00000000@final_Ex[0bin000100101010], 0bin00000000@final_Ey[0bin000100101010]), BVPLUS(16, 0bin00000000@final_Ex[0bin000100101101], 0bin00000000@final_Ey[0bin000100101101]), BVPLUS(16, 0bin00000000@final_Ex[0bin000100110000], 0bin00000000@final_Ey[0bin000100110000]), BVPLUS(16, 0bin00000000@final_Ex[0bin000100110011], 0bin00000000@final_Ey[0bin000100110011]), BVPLUS(16, 0bin00000000@final_Ex[0bin000100111111], 0bin00000000@final_Ey[0bin000100111111]), BVPLUS(16, 0bin00000000@final_Ex[0bin000101000001], 0bin00000000@final_Ey[0bin000101000001]), BVPLUS(16, 0bin00000000@final_Ex[0bin000101001000], 0bin00000000@final_Ey[0bin000101001000]), BVPLUS(16, 0bin00000000@final_Ex[0bin000101010111], 0bin00000000@final_Ey[0bin000101010111]), BVPLUS(16, 0bin00000000@final_Ex[0bin000101011010], 0bin00000000@final_Ey[0bin000101011010]), BVPLUS(16, 0bin00000000@final_Ex[0bin000101100000], 0bin00000000@final_Ey[0bin000101100000]), BVPLUS(16, 0bin00000000@final_Ex[0bin000101101000], 0bin00000000@final_Ey[0bin000101101000]), BVPLUS(16, 0bin00000000@final_Ex[0bin000101101010], 0bin00000000@final_Ey[0bin000101101010]), BVPLUS(16, 0bin00000000@final_Ex[0bin000101101011], 0bin00000000@final_Ey[0bin000101101011]), BVPLUS(16, 0bin00000000@final_Ex[0bin000101101100], 0bin00000000@final_Ey[0bin000101101100]), BVPLUS(16, 0bin00000000@final_Ex[0bin000110000001], 0bin00000000@final_Ey[0bin000110000001]), BVPLUS(16, 0bin00000000@final_Ex[0bin000110010000], 0bin00000000@final_Ey[0bin000110010000]), BVPLUS(16, 0bin00000000@final_Ex[0bin000110010011], 0bin00000000@final_Ey[0bin000110010011]), BVPLUS(16, 0bin00000000@final_Ex[0bin000110011100], 0bin00000000@final_Ey[0bin000110011100]), BVPLUS(16, 0bin00000000@final_Ex[0bin000111011100], 0bin00000000@final_Ey[0bin000111011100]), BVPLUS(16, 0bin00000000@final_Ex[0bin000111101011], 0bin00000000@final_Ey[0bin000111101011]), BVPLUS(16, 0bin00000000@final_Ex[0bin000111110111], 0bin00000000@final_Ey[0bin000111110111]), BVPLUS(16, 0bin00000000@final_Ex[0bin001000000000], 0bin00000000@final_Ey[0bin001000000000]), BVPLUS(16, 0bin00000000@final_Ex[0bin001000001111], 0bin00000000@final_Ey[0bin001000001111]), BVPLUS(16, 0bin00000000@final_Ex[0bin001000010010], 0bin00000000@final_Ey[0bin001000010010]), BVPLUS(16, 0bin00000000@final_Ex[0bin001000011000], 0bin00000000@final_Ey[0bin001000011000]), BVPLUS(16, 0bin00000000@final_Ex[0bin001000100000], 0bin00000000@final_Ey[0bin001000100000]), BVPLUS(16, 0bin00000000@final_Ex[0bin001000100010], 0bin00000000@final_Ey[0bin001000100010]), BVPLUS(16, 0bin00000000@final_Ex[0bin001000100011], 0bin00000000@final_Ey[0bin001000100011]), BVPLUS(16, 0bin00000000@final_Ex[0bin001000100100], 0bin00000000@final_Ey[0bin001000100100]), BVPLUS(16, 0bin00000000@final_Ex[0bin001000101110], 0bin00000000@final_Ey[0bin001000101110]), BVPLUS(16, 0bin00000000@final_Ex[0bin001001000110], 0bin00000000@final_Ey[0bin001001000110]), BVPLUS(16, 0bin00000000@final_Ex[0bin001001001110], 0bin00000000@final_Ey[0bin001001001110]), BVPLUS(16, 0bin00000000@final_Ex[0bin001001001111], 0bin00000000@final_Ey[0bin001001001111]), BVPLUS(16, 0bin00000000@final_Ex[0bin001001010001], 0bin00000000@final_Ey[0bin001001010001]), BVPLUS(16, 0bin00000000@final_Ex[0bin001001010010], 0bin00000000@final_Ey[0bin001001010010]), BVPLUS(16, 0bin00000000@final_Ex[0bin001001011100], 0bin00000000@final_Ey[0bin001001011100]), BVPLUS(16, 0bin00000000@final_Ex[0bin001001110100], 0bin00000000@final_Ey[0bin001001110100]), BVPLUS(16, 0bin00000000@final_Ex[0bin001001111100], 0bin00000000@final_Ey[0bin001001111100]), BVPLUS(16, 0bin00000000@final_Ex[0bin001001111111], 0bin00000000@final_Ey[0bin001001111111]), BVPLUS(16, 0bin00000000@final_Ex[0bin001010000000], 0bin00000000@final_Ey[0bin001010000000]), BVPLUS(16, 0bin00000000@final_Ex[0bin001010001001], 0bin00000000@final_Ey[0bin001010001001]), BVPLUS(16, 0bin00000000@final_Ex[0bin001010010101], 0bin00000000@final_Ey[0bin001010010101]), BVPLUS(16, 0bin00000000@final_Ex[0bin001010011111], 0bin00000000@final_Ey[0bin001010011111]), BVPLUS(16, 0bin00000000@final_Ex[0bin001010100001], 0bin00000000@final_Ey[0bin001010100001]), BVPLUS(16, 0bin00000000@final_Ex[0bin001010101001], 0bin00000000@final_Ey[0bin001010101001]), BVPLUS(16, 0bin00000000@final_Ex[0bin001010110000], 0bin00000000@final_Ey[0bin001010110000]), BVPLUS(16, 0bin00000000@final_Ex[0bin001010110011], 0bin00000000@final_Ey[0bin001010110011]), BVPLUS(16, 0bin00000000@final_Ex[0bin001010110101], 0bin00000000@final_Ey[0bin001010110101]), BVPLUS(16, 0bin00000000@final_Ex[0bin001010111001], 0bin00000000@final_Ey[0bin001010111001]), BVPLUS(16, 0bin00000000@final_Ex[0bin001010111101], 0bin00000000@final_Ey[0bin001010111101]), BVPLUS(16, 0bin00000000@final_Ex[0bin001011000100], 0bin00000000@final_Ey[0bin001011000100]), BVPLUS(16, 0bin00000000@final_Ex[0bin001011001000], 0bin00000000@final_Ey[0bin001011001000]), BVPLUS(16, 0bin00000000@final_Ex[0bin001011001011], 0bin00000000@final_Ey[0bin001011001011]), BVPLUS(16, 0bin00000000@final_Ex[0bin001011001110], 0bin00000000@final_Ey[0bin001011001110]), BVPLUS(16, 0bin00000000@final_Ex[0bin001011010001], 0bin00000000@final_Ey[0bin001011010001]), BVPLUS(16, 0bin00000000@final_Ex[0bin001011010100], 0bin00000000@final_Ey[0bin001011010100]), BVPLUS(16, 0bin00000000@final_Ex[0bin001011010110], 0bin00000000@final_Ey[0bin001011010110]), BVPLUS(16, 0bin00000000@final_Ex[0bin001011011101], 0bin00000000@final_Ey[0bin001011011101]), BVPLUS(16, 0bin00000000@final_Ex[0bin001011011111], 0bin00000000@final_Ey[0bin001011011111]), BVPLUS(16, 0bin00000000@final_Ex[0bin001011100010], 0bin00000000@final_Ey[0bin001011100010]), BVPLUS(16, 0bin00000000@final_Ex[0bin001011100101], 0bin00000000@final_Ey[0bin001011100101]), BVPLUS(16, 0bin00000000@final_Ex[0bin001011101001], 0bin00000000@final_Ey[0bin001011101001]), BVPLUS(16, 0bin00000000@final_Ex[0bin001011101111], 0bin00000000@final_Ey[0bin001011101111]), BVPLUS(16, 0bin00000000@final_Ex[0bin001011110100], 0bin00000000@final_Ey[0bin001011110100]), BVPLUS(16, 0bin00000000@final_Ex[0bin001011110111], 0bin00000000@final_Ey[0bin001011110111]), BVPLUS(16, 0bin00000000@final_Ex[0bin001011111011], 0bin00000000@final_Ey[0bin001011111011]), BVPLUS(16, 0bin00000000@final_Ex[0bin001011111101], 0bin00000000@final_Ey[0bin001011111101]), BVPLUS(16, 0bin00000000@final_Ex[0bin001100000000], 0bin00000000@final_Ey[0bin001100000000]), BVPLUS(16, 0bin00000000@final_Ex[0bin001100000011], 0bin00000000@final_Ey[0bin001100000011]), BVPLUS(16, 0bin00000000@final_Ex[0bin001100000101], 0bin00000000@final_Ey[0bin001100000101]), BVPLUS(16, 0bin00000000@final_Ex[0bin001100001100], 0bin00000000@final_Ey[0bin001100001100]), BVPLUS(16, 0bin00000000@final_Ex[0bin001100001111], 0bin00000000@final_Ey[0bin001100001111]), BVPLUS(16, 0bin00000000@final_Ex[0bin001100010101], 0bin00000000@final_Ey[0bin001100010101]), BVPLUS(16, 0bin00000000@final_Ex[0bin001100011110], 0bin00000000@final_Ey[0bin001100011110]), BVPLUS(16, 0bin00000000@final_Ex[0bin001100100100], 0bin00000000@final_Ey[0bin001100100100]), BVPLUS(16, 0bin00000000@final_Ex[0bin001100100111], 0bin00000000@final_Ey[0bin001100100111]), BVPLUS(16, 0bin00000000@final_Ex[0bin001100101010], 0bin00000000@final_Ey[0bin001100101010]), BVPLUS(16, 0bin00000000@final_Ex[0bin001100101101], 0bin00000000@final_Ey[0bin001100101101]), BVPLUS(16, 0bin00000000@final_Ex[0bin001100111001], 0bin00000000@final_Ey[0bin001100111001]), BVPLUS(16, 0bin00000000@final_Ex[0bin001100111011], 0bin00000000@final_Ey[0bin001100111011]), BVPLUS(16, 0bin00000000@final_Ex[0bin001101000010], 0bin00000000@final_Ey[0bin001101000010]), BVPLUS(16, 0bin00000000@final_Ex[0bin001101011010], 0bin00000000@final_Ey[0bin001101011010]), BVPLUS(16, 0bin00000000@final_Ex[0bin001101100010], 0bin00000000@final_Ey[0bin001101100010]), BVPLUS(16, 0bin00000000@final_Ex[0bin001101100101], 0bin00000000@final_Ey[0bin001101100101]), BVPLUS(16, 0bin00000000@final_Ex[0bin001101100110], 0bin00000000@final_Ey[0bin001101100110]), BVPLUS(16, 0bin00000000@final_Ex[0bin001101111011], 0bin00000000@final_Ey[0bin001101111011]), BVPLUS(16, 0bin00000000@final_Ex[0bin001110010110], 0bin00000000@final_Ey[0bin001110010110]), BVPLUS(16, 0bin00000000@final_Ex[0bin001110100000], 0bin00000000@final_Ey[0bin001110100000]), BVPLUS(16, 0bin00000000@final_Ex[0bin001110100100], 0bin00000000@final_Ey[0bin001110100100]), BVPLUS(16, 0bin00000000@final_Ex[0bin001111000111], 0bin00000000@final_Ey[0bin001111000111]), BVPLUS(16, 0bin00000000@final_Ex[0bin001111001101], 0bin00000000@final_Ey[0bin001111001101]), BVPLUS(16, 0bin00000000@final_Ex[0bin001111010110], 0bin00000000@final_Ey[0bin001111010110]), BVPLUS(16, 0bin00000000@final_Ex[0bin001111011000], 0bin00000000@final_Ey[0bin001111011000]), BVPLUS(16, 0bin00000000@final_Ex[0bin001111011111], 0bin00000000@final_Ey[0bin001111011111]), BVPLUS(16, 0bin00000000@final_Ex[0bin001111100010], 0bin00000000@final_Ey[0bin001111100010]), BVPLUS(16, 0bin00000000@final_Ex[0bin001111100101], 0bin00000000@final_Ey[0bin001111100101]), BVPLUS(16, 0bin00000000@final_Ex[0bin001111110001], 0bin00000000@final_Ey[0bin001111110001]), BVPLUS(16, 0bin00000000@final_Ex[0bin001111110011], 0bin00000000@final_Ey[0bin001111110011]), BVPLUS(16, 0bin00000000@final_Ex[0bin010000000101], 0bin00000000@final_Ey[0bin010000000101]), BVPLUS(16, 0bin00000000@final_Ex[0bin010000100000], 0bin00000000@final_Ey[0bin010000100000]), BVPLUS(16, 0bin00000000@final_Ex[0bin010000101010], 0bin00000000@final_Ey[0bin010000101010]), BVPLUS(16, 0bin00000000@final_Ex[0bin010000101110], 0bin00000000@final_Ey[0bin010000101110]), BVPLUS(16, 0bin00000000@final_Ex[0bin010001010001], 0bin00000000@final_Ey[0bin010001010001]), BVPLUS(16, 0bin00000000@final_Ex[0bin010001010111], 0bin00000000@final_Ey[0bin010001010111]), BVPLUS(16, 0bin00000000@final_Ex[0bin010001100000], 0bin00000000@final_Ey[0bin010001100000]), BVPLUS(16, 0bin00000000@final_Ex[0bin010001100010], 0bin00000000@final_Ey[0bin010001100010]), BVPLUS(16, 0bin00000000@final_Ex[0bin010001100110], 0bin00000000@final_Ey[0bin010001100110]), BVPLUS(16, 0bin00000000@final_Ex[0bin010001101100], 0bin00000000@final_Ey[0bin010001101100]), BVPLUS(16, 0bin00000000@final_Ex[0bin010001101111], 0bin00000000@final_Ey[0bin010001101111]), BVPLUS(16, 0bin00000000@final_Ex[0bin010001111011], 0bin00000000@final_Ey[0bin010001111011]), BVPLUS(16, 0bin00000000@final_Ex[0bin010001111101], 0bin00000000@final_Ey[0bin010001111101]), BVPLUS(16, 0bin00000000@final_Ex[0bin010010000100], 0bin00000000@final_Ey[0bin010010000100]), BVPLUS(16, 0bin00000000@final_Ex[0bin010010011100], 0bin00000000@final_Ey[0bin010010011100]), BVPLUS(16, 0bin00000000@final_Ex[0bin010010100100], 0bin00000000@final_Ey[0bin010010100100]), BVPLUS(16, 0bin00000000@final_Ex[0bin010010100111], 0bin00000000@final_Ey[0bin010010100111]), BVPLUS(16, 0bin00000000@final_Ex[0bin010010101000], 0bin00000000@final_Ey[0bin010010101000]), BVPLUS(16, 0bin00000000@final_Ex[0bin010010110001], 0bin00000000@final_Ey[0bin010010110001]), BVPLUS(16, 0bin00000000@final_Ex[0bin010010111011], 0bin00000000@final_Ey[0bin010010111011]), BVPLUS(16, 0bin00000000@final_Ex[0bin010010111101], 0bin00000000@final_Ey[0bin010010111101]), BVPLUS(16, 0bin00000000@final_Ex[0bin010011001001], 0bin00000000@final_Ey[0bin010011001001]), BVPLUS(16, 0bin00000000@final_Ex[0bin010011010001], 0bin00000000@final_Ey[0bin010011010001]), BVPLUS(16, 0bin00000000@final_Ex[0bin010011011000], 0bin00000000@final_Ey[0bin010011011000]), BVPLUS(16, 0bin00000000@final_Ex[0bin010011011011], 0bin00000000@final_Ey[0bin010011011011]), BVPLUS(16, 0bin00000000@final_Ex[0bin010011100001], 0bin00000000@final_Ey[0bin010011100001]), BVPLUS(16, 0bin00000000@final_Ex[0bin010011101010], 0bin00000000@final_Ey[0bin010011101010]), BVPLUS(16, 0bin00000000@final_Ex[0bin010011101100], 0bin00000000@final_Ey[0bin010011101100]), BVPLUS(16, 0bin00000000@final_Ex[0bin010011110000], 0bin00000000@final_Ey[0bin010011110000]), BVPLUS(16, 0bin00000000@final_Ex[0bin010011110011], 0bin00000000@final_Ey[0bin010011110011]), BVPLUS(16, 0bin00000000@final_Ex[0bin010011111001], 0bin00000000@final_Ey[0bin010011111001]), BVPLUS(16, 0bin00000000@final_Ex[0bin010100000101], 0bin00000000@final_Ey[0bin010100000101]), BVPLUS(16, 0bin00000000@final_Ex[0bin010100000111], 0bin00000000@final_Ey[0bin010100000111]), BVPLUS(16, 0bin00000000@final_Ex[0bin010100001101], 0bin00000000@final_Ey[0bin010100001101]), BVPLUS(16, 0bin00000000@final_Ex[0bin010100010111], 0bin00000000@final_Ey[0bin010100010111]), BVPLUS(16, 0bin00000000@final_Ex[0bin010100011001], 0bin00000000@final_Ey[0bin010100011001]), BVPLUS(16, 0bin00000000@final_Ex[0bin010100100011], 0bin00000000@final_Ey[0bin010100100011]), BVPLUS(16, 0bin00000000@final_Ex[0bin010100101101], 0bin00000000@final_Ey[0bin010100101101]), BVPLUS(16, 0bin00000000@final_Ex[0bin010100110100], 0bin00000000@final_Ey[0bin010100110100]), BVPLUS(16, 0bin00000000@final_Ex[0bin010100111010], 0bin00000000@final_Ey[0bin010100111010]), BVPLUS(16, 0bin00000000@final_Ex[0bin010100111110], 0bin00000000@final_Ey[0bin010100111110]), BVPLUS(16, 0bin00000000@final_Ex[0bin010101000010], 0bin00000000@final_Ey[0bin010101000010]), BVPLUS(16, 0bin00000000@final_Ex[0bin010101000011], 0bin00000000@final_Ey[0bin010101000011]), BVPLUS(16, 0bin00000000@final_Ex[0bin010101000100], 0bin00000000@final_Ey[0bin010101000100]), BVPLUS(16, 0bin00000000@final_Ex[0bin010101001001], 0bin00000000@final_Ey[0bin010101001001]), BVPLUS(16, 0bin00000000@final_Ex[0bin010101010000], 0bin00000000@final_Ey[0bin010101010000]), BVPLUS(16, 0bin00000000@final_Ex[0bin010101100101], 0bin00000000@final_Ey[0bin010101100101]), BVPLUS(16, 0bin00000000@final_Ex[0bin010101100111], 0bin00000000@final_Ey[0bin010101100111]), BVPLUS(16, 0bin00000000@final_Ex[0bin010101101011], 0bin00000000@final_Ey[0bin010101101011]), BVPLUS(16, 0bin00000000@final_Ex[0bin010101101111], 0bin00000000@final_Ey[0bin010101101111]), BVPLUS(16, 0bin00000000@final_Ex[0bin010101110100], 0bin00000000@final_Ey[0bin010101110100]), BVPLUS(16, 0bin00000000@final_Ex[0bin010101110110], 0bin00000000@final_Ey[0bin010101110110]), BVPLUS(16, 0bin00000000@final_Ex[0bin010101111010], 0bin00000000@final_Ey[0bin010101111010]), BVPLUS(16, 0bin00000000@final_Ex[0bin010101111101], 0bin00000000@final_Ey[0bin010101111101]), BVPLUS(16, 0bin00000000@final_Ex[0bin010110000000], 0bin00000000@final_Ey[0bin010110000000]), BVPLUS(16, 0bin00000000@final_Ex[0bin010110000110], 0bin00000000@final_Ey[0bin010110000110]), BVPLUS(16, 0bin00000000@final_Ex[0bin010110001000], 0bin00000000@final_Ey[0bin010110001000]), BVPLUS(16, 0bin00000000@final_Ex[0bin010110001111], 0bin00000000@final_Ey[0bin010110001111]), BVPLUS(16, 0bin00000000@final_Ex[0bin010110010001], 0bin00000000@final_Ey[0bin010110010001]), BVPLUS(16, 0bin00000000@final_Ex[0bin010110011011], 0bin00000000@final_Ey[0bin010110011011]), BVPLUS(16, 0bin00000000@final_Ex[0bin010110100011], 0bin00000000@final_Ey[0bin010110100011]), BVPLUS(16, 0bin00000000@final_Ex[0bin010110110101], 0bin00000000@final_Ey[0bin010110110101]), BVPLUS(16, 0bin00000000@final_Ex[0bin010110111110], 0bin00000000@final_Ey[0bin010110111110]), BVPLUS(16, 0bin00000000@final_Ex[0bin010111111110], 0bin00000000@final_Ey[0bin010111111110]), BVPLUS(16, 0bin00000000@final_Ex[0bin011000001101], 0bin00000000@final_Ey[0bin011000001101]), BVPLUS(16, 0bin00000000@final_Ex[0bin011000011001], 0bin00000000@final_Ey[0bin011000011001]), BVPLUS(16, 0bin00000000@final_Ex[0bin011000100101], 0bin00000000@final_Ey[0bin011000100101]), BVPLUS(16, 0bin00000000@final_Ex[0bin011000101101], 0bin00000000@final_Ey[0bin011000101101]), BVPLUS(16, 0bin00000000@final_Ex[0bin011000111100], 0bin00000000@final_Ey[0bin011000111100]), BVPLUS(16, 0bin00000000@final_Ex[0bin011001001000], 0bin00000000@final_Ey[0bin011001001000]), BVPLUS(16, 0bin00000000@final_Ex[0bin011001011010], 0bin00000000@final_Ey[0bin011001011010]), BVPLUS(16, 0bin00000000@final_Ex[0bin011001101001], 0bin00000000@final_Ey[0bin011001101001]), BVPLUS(16, 0bin00000000@final_Ex[0bin011001110101], 0bin00000000@final_Ey[0bin011001110101]), BVPLUS(16, 0bin00000000@final_Ex[0bin011001111101], 0bin00000000@final_Ey[0bin011001111101]), BVPLUS(16, 0bin00000000@final_Ex[0bin011010000111], 0bin00000000@final_Ey[0bin011010000111]), BVPLUS(16, 0bin00000000@final_Ex[0bin011010001001], 0bin00000000@final_Ey[0bin011010001001]), BVPLUS(16, 0bin00000000@final_Ex[0bin011010010011], 0bin00000000@final_Ey[0bin011010010011]), BVPLUS(16, 0bin00000000@final_Ex[0bin011010010101], 0bin00000000@final_Ey[0bin011010010101]), BVPLUS(16, 0bin00000000@final_Ex[0bin011010100100], 0bin00000000@final_Ey[0bin011010100100]), BVPLUS(16, 0bin00000000@final_Ex[0bin011010101010], 0bin00000000@final_Ey[0bin011010101010]), BVPLUS(16, 0bin00000000@final_Ex[0bin011010101110], 0bin00000000@final_Ey[0bin011010101110]), BVPLUS(16, 0bin00000000@final_Ex[0bin011010110010], 0bin00000000@final_Ey[0bin011010110010]), BVPLUS(16, 0bin00000000@final_Ex[0bin011010110011], 0bin00000000@final_Ey[0bin011010110011]), BVPLUS(16, 0bin00000000@final_Ex[0bin011010110100], 0bin00000000@final_Ey[0bin011010110100]), BVPLUS(16, 0bin00000000@final_Ex[0bin011010111001], 0bin00000000@final_Ey[0bin011010111001]), BVPLUS(16, 0bin00000000@final_Ex[0bin011011000000], 0bin00000000@final_Ey[0bin011011000000]), BVPLUS(16, 0bin00000000@final_Ex[0bin011011100001], 0bin00000000@final_Ey[0bin011011100001]), BVPLUS(16, 0bin00000000@final_Ex[0bin011100001010], 0bin00000000@final_Ey[0bin011100001010]), BVPLUS(16, 0bin00000000@final_Ex[0bin011100001110], 0bin00000000@final_Ey[0bin011100001110]), BVPLUS(16, 0bin00000000@final_Ex[0bin011100110100], 0bin00000000@final_Ey[0bin011100110100]), BVPLUS(16, 0bin00000000@final_Ex[0bin011100111000], 0bin00000000@final_Ey[0bin011100111000]), BVPLUS(16, 0bin00000000@final_Ex[0bin011100111100], 0bin00000000@final_Ey[0bin011100111100]), BVPLUS(16, 0bin00000000@final_Ex[0bin011100111101], 0bin00000000@final_Ey[0bin011100111101]), BVPLUS(16, 0bin00000000@final_Ex[0bin011100111110], 0bin00000000@final_Ey[0bin011100111110]), BVPLUS(16, 0bin00000000@final_Ex[0bin011101000011], 0bin00000000@final_Ey[0bin011101000011]), BVPLUS(16, 0bin00000000@final_Ex[0bin011101001010], 0bin00000000@final_Ey[0bin011101001010]), BVPLUS(16, 0bin00000000@final_Ex[0bin011101100010], 0bin00000000@final_Ey[0bin011101100010]), BVPLUS(16, 0bin00000000@final_Ex[0bin011101100110], 0bin00000000@final_Ey[0bin011101100110]), BVPLUS(16, 0bin00000000@final_Ex[0bin011101101010], 0bin00000000@final_Ey[0bin011101101010]), BVPLUS(16, 0bin00000000@final_Ex[0bin011101101011], 0bin00000000@final_Ey[0bin011101101011]), BVPLUS(16, 0bin00000000@final_Ex[0bin011101101100], 0bin00000000@final_Ey[0bin011101101100]), BVPLUS(16, 0bin00000000@final_Ex[0bin011101110001], 0bin00000000@final_Ey[0bin011101110001]), BVPLUS(16, 0bin00000000@final_Ex[0bin011101111000], 0bin00000000@final_Ey[0bin011101111000]), BVPLUS(16, 0bin00000000@final_Ex[0bin011110001101], 0bin00000000@final_Ey[0bin011110001101]), BVPLUS(16, 0bin00000000@final_Ex[0bin011110001111], 0bin00000000@final_Ey[0bin011110001111]), BVPLUS(16, 0bin00000000@final_Ex[0bin011110010011], 0bin00000000@final_Ey[0bin011110010011]), BVPLUS(16, 0bin00000000@final_Ex[0bin011110010111], 0bin00000000@final_Ey[0bin011110010111]), BVPLUS(16, 0bin00000000@final_Ex[0bin011110011100], 0bin00000000@final_Ey[0bin011110011100]), BVPLUS(16, 0bin00000000@final_Ex[0bin011110011110], 0bin00000000@final_Ey[0bin011110011110]), BVPLUS(16, 0bin00000000@final_Ex[0bin011110100010], 0bin00000000@final_Ey[0bin011110100010]), BVPLUS(16, 0bin00000000@final_Ex[0bin011110100101], 0bin00000000@final_Ey[0bin011110100101]), BVPLUS(16, 0bin00000000@final_Ex[0bin011110101000], 0bin00000000@final_Ey[0bin011110101000]), BVPLUS(16, 0bin00000000@final_Ex[0bin011110101011], 0bin00000000@final_Ey[0bin011110101011]), BVPLUS(16, 0bin00000000@final_Ex[0bin011110101110], 0bin00000000@final_Ey[0bin011110101110]), BVPLUS(16, 0bin00000000@final_Ex[0bin011110110000], 0bin00000000@final_Ey[0bin011110110000]), BVPLUS(16, 0bin00000000@final_Ex[0bin011110111001], 0bin00000000@final_Ey[0bin011110111001]), BVPLUS(16, 0bin00000000@final_Ex[0bin011110111100], 0bin00000000@final_Ey[0bin011110111100]), BVPLUS(16, 0bin00000000@final_Ex[0bin011110111111], 0bin00000000@final_Ey[0bin011110111111]), BVPLUS(16, 0bin00000000@final_Ex[0bin011111000011], 0bin00000000@final_Ey[0bin011111000011]), BVPLUS(16, 0bin00000000@final_Ex[0bin011111001001], 0bin00000000@final_Ey[0bin011111001001]), BVPLUS(16, 0bin00000000@final_Ex[0bin011111001011], 0bin00000000@final_Ey[0bin011111001011]), BVPLUS(16, 0bin00000000@final_Ex[0bin011111001110], 0bin00000000@final_Ey[0bin011111001110]), BVPLUS(16, 0bin00000000@final_Ex[0bin011111010001], 0bin00000000@final_Ey[0bin011111010001]), BVPLUS(16, 0bin00000000@final_Ex[0bin011111010101], 0bin00000000@final_Ey[0bin011111010101]), BVPLUS(16, 0bin00000000@final_Ex[0bin011111010111], 0bin00000000@final_Ey[0bin011111010111]), BVPLUS(16, 0bin00000000@final_Ex[0bin011111011010], 0bin00000000@final_Ey[0bin011111011010]), BVPLUS(16, 0bin00000000@final_Ex[0bin011111011101], 0bin00000000@final_Ey[0bin011111011101]), BVPLUS(16, 0bin00000000@final_Ex[0bin011111011111], 0bin00000000@final_Ey[0bin011111011111]), BVPLUS(16, 0bin00000000@final_Ex[0bin011111101001], 0bin00000000@final_Ey[0bin011111101001]), BVPLUS(16, 0bin00000000@final_Ex[0bin011111101111], 0bin00000000@final_Ey[0bin011111101111]), BVPLUS(16, 0bin00000000@final_Ex[0bin011111111000], 0bin00000000@final_Ey[0bin011111111000]), BVPLUS(16, 0bin00000000@final_Ex[0bin011111111010], 0bin00000000@final_Ey[0bin011111111010]), BVPLUS(16, 0bin00000000@final_Ex[0bin011111111110], 0bin00000000@final_Ey[0bin011111111110]), BVPLUS(16, 0bin00000000@final_Ex[0bin100000000001], 0bin00000000@final_Ey[0bin100000000001]), BVPLUS(16, 0bin00000000@final_Ex[0bin100000000100], 0bin00000000@final_Ey[0bin100000000100]), BVPLUS(16, 0bin00000000@final_Ex[0bin100000000111], 0bin00000000@final_Ey[0bin100000000111]), BVPLUS(16, 0bin00000000@final_Ex[0bin100000010011], 0bin00000000@final_Ey[0bin100000010011])) ); +ASSERT (BVGE(total_energy, 0bin0000000000000010)); +QUERY FALSE; diff --git a/tests/for-tests/for-boolean.cvc b/tests/for-tests/for-boolean.cvc new file mode 100644 index 0000000..dde64ef --- /dev/null +++ b/tests/for-tests/for-boolean.cvc @@ -0,0 +1,7 @@ +ASSERT ( +FOR(j:BITVECTOR(8);0x00;0xFF;0x01){ + A(j) <=> B(j) +} +); + +QUERY FALSE; \ No newline at end of file diff --git a/tests/for-tests/for1.cvc b/tests/for-tests/for1.cvc new file mode 100644 index 0000000..2b9864d --- /dev/null +++ b/tests/for-tests/for1.cvc @@ -0,0 +1,13 @@ +A : ARRAY BITVECTOR(8) OF BITVECTOR(8); +B : ARRAY BITVECTOR(8) OF BITVECTOR(8); + + +ASSERT A[0x00] /= B[0x00]; + +ASSERT ( +FOR(j:BITVECTOR(8);0x00;0xFF;0x01){ + A[j] = B[j] +} +); + +QUERY FALSE; \ No newline at end of file diff --git a/tests/for-tests/for2.cvc b/tests/for-tests/for2.cvc new file mode 100644 index 0000000..2760a34 --- /dev/null +++ b/tests/for-tests/for2.cvc @@ -0,0 +1,12 @@ +A : ARRAY BITVECTOR(8) OF BITVECTOR(8); +B : ARRAY BITVECTOR(8) OF BITVECTOR(8); + +ASSERT ( +FOR(j:BITVECTOR(8);0x00;0x02;0x01){ +FOR(i:BITVECTOR(8);0x00;0x03;0x01; EXCEPT j = i){ + A[j] = B[i] +} +} +); + +QUERY FALSE; \ No newline at end of file